ai-browser-profile 1.0.5

package/ai_browser_profile/embeddings.py

@@ -0,0 +1,196 @@
+"""Lazy-loading embedding model + vector storage for semantic search.
+
+Uses a plain SQLite table for embeddings (no sqlite-vec extension needed)
+and computes cosine similarity in Python via numpy.
+
+Model: nomic-embed-text-v1.5 (768-dim, 2K context, MTEB ~65).
+Runtime: ONNX Runtime (~50MB) with pre-built quantized model (~131MB).
+No PyTorch, transformers, scipy, or sklearn needed.
+
+Nomic uses task prefixes: "search_document: " for stored texts,
+"search_query: " for queries.
+"""
+
+import logging
+import struct
+from typing import Optional
+
+log = logging.getLogger(__name__)
+
+# Module-level state — loaded on first call
+_session = None
+_tokenizer = None
+
+EMBEDDING_DIM = 768
+MODEL_NAME = "nomic-ai/nomic-embed-text-v1.5"
+ONNX_FILE = "onnx/model_quantized.onnx"
+MAX_LENGTH = 512
+
+
+def _load_model():
+    """Load ONNX model + tokenizer on first use (~131MB download)."""
+    global _session, _tokenizer
+    if _session is not None:
+        return True
+    try:
+        import onnxruntime as ort
+        from huggingface_hub import hf_hub_download
+        from tokenizers import Tokenizer
+
+        onnx_path = hf_hub_download(MODEL_NAME, ONNX_FILE)
+        tok_path = hf_hub_download(MODEL_NAME, "tokenizer.json")
+
+        providers = ['CoreMLExecutionProvider', 'CPUExecutionProvider'] \
+            if 'CoreMLExecutionProvider' in ort.get_available_providers() \
+            else ['CPUExecutionProvider']
+        _session = ort.InferenceSession(onnx_path, providers=providers)
+
+        _tokenizer = Tokenizer.from_file(tok_path)
+        # Only truncate; padding is done dynamically per-batch in _embed_raw
+        _tokenizer.enable_truncation(max_length=MAX_LENGTH)
+
+        log.info(f"Loaded embedding model: {MODEL_NAME} (ONNX, {_session.get_providers()})")
+        return True
+    except ImportError as e:
+        log.warning(f"ONNX runtime dependencies not installed — semantic search disabled: {e}")
+        return False
+    except Exception as e:
+        log.warning(f"Failed to load embedding model: {e}")
+        return False
+
+
+def _embed_raw(texts: list[str]) -> list[Optional[list[float]]]:
+    """Embed pre-prefixed texts via ONNX Runtime. Returns normalized vectors."""
+    import numpy as np
+
+    results = []
+    batch_size = 32
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i:i + batch_size]
+        encoded = _tokenizer.encode_batch(batch)
+
+        # Dynamic padding: pad to max length in this batch, not MAX_LENGTH
+        max_len = max(len(e.ids) for e in encoded)
+        input_ids = np.zeros((len(encoded), max_len), dtype=np.int64)
+        attention_mask = np.zeros((len(encoded), max_len), dtype=np.int64)
+        for j, e in enumerate(encoded):
+            seq_len = len(e.ids)
+            input_ids[j, :seq_len] = e.ids
+            attention_mask[j, :seq_len] = e.attention_mask
+        token_type_ids = np.zeros_like(input_ids)
+
+        outputs = _session.run(None, {
+            "input_ids": input_ids,
+            "attention_mask": attention_mask,
+            "token_type_ids": token_type_ids,
+        })
+
+        last_hidden = outputs[0]  # (batch, seq, 768)
+        mask = attention_mask[:, :, None].astype(np.float32)
+        emb = (last_hidden * mask).sum(axis=1) / mask.sum(axis=1)
+        norms = np.linalg.norm(emb, axis=1, keepdims=True)
+        emb = emb / norms
+
+        for vec in emb:
+            results.append(vec.tolist())
+
+    return results
+
+
+def is_available() -> bool:
+    """Check if embedding model can be loaded."""
+    return _load_model()
+
+
+def embed_text(text: str, prefix: str = "search_document") -> Optional[list[float]]:
+    """Embed a single text string. Returns 768-dim vector or None if unavailable.
+
+    Args:
+        text: The text to embed.
+        prefix: "search_document" for storing, "search_query" for searching.
+    """
+    if not _load_model():
+        return None
+    results = _embed_raw([f"{prefix}: {text}"])
+    return results[0] if results else None
+
+
+def embed_batch(texts: list[str], prefix: str = "search_document") -> list[Optional[list[float]]]:
+    """Embed a batch of texts. Returns list of 768-dim vectors."""
+    if not _load_model():
+        return [None] * len(texts)
+    prefixed = [f"{prefix}: {t}" for t in texts]
+    return _embed_raw(prefixed)
+
+
+def _serialize_vec(vec: list[float]) -> bytes:
+    """Serialize a float vector to bytes for SQLite BLOB storage."""
+    return struct.pack(f"{len(vec)}f", *vec)
+
+
+def _deserialize_vec(blob: bytes) -> list[float]:
+    """Deserialize bytes back to float vector."""
+    n = len(blob) // 4
+    return list(struct.unpack(f"{n}f", blob))
+
+
+def setup_embeddings_table(conn) -> bool:
+    """Create memory_embeddings table (plain SQLite, no extensions needed)."""
+    try:
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS memory_embeddings (
+                memory_id INTEGER PRIMARY KEY,
+                embedding BLOB NOT NULL
+            )
+        """)
+        conn.commit()
+        return True
+    except Exception as e:
+        log.warning(f"Failed to create embeddings table: {e}")
+        return False
+
+
+def store_embedding(conn, memory_id: int, vec: list[float]):
+    """Store an embedding for a memory."""
+    try:
+        conn.execute(
+            "INSERT OR REPLACE INTO memory_embeddings (memory_id, embedding) VALUES (?, ?)",
+            (memory_id, _serialize_vec(vec)),
+        )
+    except Exception as e:
+        log.debug(f"Failed to store embedding for {memory_id}: {e}")
+
+
+def cosine_search(conn, query_vec: list[float], limit: int = 20,
+                  threshold: float = 0.5) -> list[tuple[int, float]]:
+    """Search for similar memories by embedding.
+
+    Computes cosine similarity in Python (vectors are pre-normalized).
+    Returns [(memory_id, similarity)] sorted by similarity descending.
+    """
+    try:
+        import numpy as np
+    except ImportError:
+        log.warning("numpy not available for cosine search")
+        return []
+
+    try:
+        rows = conn.execute("SELECT memory_id, embedding FROM memory_embeddings").fetchall()
+    except Exception:
+        return []
+
+    if not rows:
+        return []
+
+    q = np.array(query_vec, dtype=np.float32)
+
+    results = []
+    for mem_id, blob in rows:
+        vec = np.frombuffer(blob, dtype=np.float32)
+        # Dot product of normalized vectors = cosine similarity
+        sim = float(np.dot(q, vec))
+        if sim >= threshold:
+            results.append((mem_id, sim))
+
+    results.sort(key=lambda x: -x[1])
+    return results[:limit]

package/ai_browser_profile/extract.py

@@ -0,0 +1,108 @@
+"""Orchestrate memory extraction from all browser sources."""
+
+import logging
+import time
+from typing import Optional, Set
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.embeddings import setup_embeddings_table
+from ai_browser_profile.ingestors.browser_detect import detect_browsers
+from ai_browser_profile.ingestors.webdata import ingest_webdata
+from ai_browser_profile.ingestors.history import ingest_history
+from ai_browser_profile.ingestors.logins import ingest_logins
+from ai_browser_profile.ingestors.bookmarks import ingest_bookmarks
+
+log = logging.getLogger(__name__)
+
+
+def _timed(name, func, *args, **kwargs):
+    """Run func with timing, log duration."""
+    log.info(f"[{name}] starting...")
+    t0 = time.monotonic()
+    result = func(*args, **kwargs)
+    elapsed = time.monotonic() - t0
+    log.info(f"[{name}] done in {elapsed:.1f}s")
+    return result
+
+
+def extract_memories(memories_db_path: str = "memories.db",
+                     browsers: Optional[Set[str]] = None,
+                     skip_indexeddb: bool = False,
+                     skip_localstorage: bool = False,
+                     skip_notion: bool = False) -> MemoryDB:
+    """Build the memories database directly from browser files.
+
+    Args:
+        memories_db_path: Output database path.
+        browsers: Set of browser names to scan (None = all).
+        skip_indexeddb: Skip IndexedDB extraction (requires ccl_chromium_reader).
+        skip_localstorage: Skip Local Storage extraction (requires ccl_chromium_reader).
+    """
+    total_start = time.monotonic()
+    mem = MemoryDB(memories_db_path, defer_embeddings=True)
+    profiles = detect_browsers(allowed=browsers)
+    log.info(f"Extracting memories from {len(profiles)} profiles...")
+
+    # 1. Autofill — saved form data, addresses, credit cards
+    _timed("Autofill", ingest_webdata, mem)
+
+    # 2. History — tools and services used
+    _timed("History", ingest_history, mem, profiles)
+
+    # 3. Bookmarks — interests and saved links
+    _timed("Bookmarks", ingest_bookmarks, mem, profiles)
+
+    # 4. Logins — saved accounts per site
+    _timed("Logins", ingest_logins, mem, profiles)
+
+    # 5. LinkedIn — connections from Local Storage
+    if not skip_localstorage:
+        try:
+            from ai_browser_profile.ingestors.localstorage import ingest_localstorage
+            _timed("LinkedIn", ingest_localstorage, mem, profiles)
+        except ImportError:
+            log.warning("ccl_chromium_reader not installed — skipping LinkedIn")
+
+    # 6. Notion — workspace contacts, pages, meetings
+    if not skip_notion:
+        try:
+            from ai_browser_profile.ingestors.notion import ingest_notion
+            _timed("Notion", ingest_notion, mem)
+        except Exception as e:
+            log.warning(f"Notion ingestor failed: {e}")
+
+    # -- Interim profile: core data is ready, show it before slow steps --
+    mem.conn.commit()
+    # Run cleanup before showing profile so noise is removed
+    from clean import run_cleanup
+    log.info("Running interim cleanup...")
+    mem.close()
+    run_cleanup(db_path=memories_db_path)
+    mem = MemoryDB(memories_db_path, defer_embeddings=True)
+    interim_profile = mem.profile_text()
+    log.info(f"Interim profile ready (WhatsApp + embeddings still running):\n{interim_profile}")
+
+    # 7. WhatsApp — contacts from IndexedDB (slow, runs last)
+    if not skip_indexeddb:
+        try:
+            from ai_browser_profile.ingestors.indexeddb import ingest_indexeddb
+            _timed("WhatsApp", ingest_indexeddb, mem, profiles)
+        except ImportError:
+            log.warning("ccl_chromium_reader not installed — skipping WhatsApp")
+
+    mem.conn.commit()
+
+    # 8. Embeddings — backfill all at once (loads ONNX model once, batches efficiently)
+    mem._vec_ready = setup_embeddings_table(mem.conn)
+    mem._defer_embeddings = False
+    if mem._vec_ready:
+        _timed("Embeddings", mem.backfill_embeddings)
+
+    total_elapsed = time.monotonic() - total_start
+    stats = mem.stats()
+    log.info(
+        f"Memories: {stats['total_memories']} total, "
+        f"tags: {', '.join(f'{t}={c}' for t, c in list(stats['by_tag'].items())[:10])}"
+    )
+    log.info(f"Total extraction time: {total_elapsed:.1f}s")
+    return mem

package/ai_browser_profile/ingestors/bookmarks.py

@@ -0,0 +1,185 @@
+"""Ingest bookmark memories from browser bookmark files."""
+
+import json
+import plistlib
+import shutil
+import sqlite3
+import logging
+from pathlib import Path
+
+from ai_browser_profile.db import MemoryDB
+from ai_browser_profile.ingestors.browser_detect import BrowserProfile, copy_db, domain
+from ai_browser_profile.ingestors.constants import SERVICE_NAMES
+
+log = logging.getLogger(__name__)
+
+# URLs to skip entirely
+_SKIP_SCHEMES = ("chrome://", "chrome-extension://", "about:", "javascript:", "edge://", "brave://")
+
+# Default bookmarks that are noise
+_SKIP_DOMAINS = {"www.apple.com", "apple.com", "support.apple.com"}
+_SKIP_URLS = {"https://www.google.com/", "http://www.google.com/", "https://google.com/", "http://google.com/"}
+
+# Domain keywords for tag inference on unknown bookmarks
+_TAG_KEYWORDS = {
+    "tool": {"github", "gitlab", "stackoverflow", "stackexchange", "dev", "codepen",
+             "codesandbox", "npm", "pypi", "crates", "packagist", "brew"},
+    "knowledge": {"docs", "wiki", "learn", "tutorial", "guide", "course", "edu",
+                  "arxiv", "scholar", "paper", "blog", "medium", "substack"},
+    "social": {"twitter", "x.com", "linkedin", "facebook", "instagram", "reddit",
+               "mastodon", "threads", "tiktok", "youtube"},
+}
+
+
+def _should_skip(url: str) -> bool:
+    """Return True if this bookmark URL should be skipped."""
+    if any(url.startswith(s) for s in _SKIP_SCHEMES):
+        return True
+    if url in _SKIP_URLS:
+        return True
+    d = domain(url)
+    if d in _SKIP_DOMAINS:
+        return True
+    if not d:
+        return True
+    return False
+
+
+def _infer_tags(d: str) -> list[str]:
+    """Infer tags for an unknown bookmark domain."""
+    tags = {"knowledge"}
+    d_lower = d.lower()
+    for tag, keywords in _TAG_KEYWORDS.items():
+        for kw in keywords:
+            if kw in d_lower:
+                tags.add(tag)
+                break
+    return list(tags)
+
+
+def _walk_chromium_bookmarks(node: dict, out: list[dict]):
+    """Recursively walk a Chromium bookmark tree node."""
+    if node.get("type") == "url":
+        url = node.get("url", "")
+        title = node.get("name", "")
+        if url and not _should_skip(url):
+            out.append({"url": url, "title": title})
+    for child in node.get("children", []):
+        _walk_chromium_bookmarks(child, out)
+
+
+def _chromium_bookmarks(profile: BrowserProfile) -> list[dict]:
+    """Read bookmarks from Chromium JSON file."""
+    bm_path = profile.path / "Bookmarks"
+    if not bm_path.exists():
+        return []
+    try:
+        with open(bm_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        out: list[dict] = []
+        roots = data.get("roots", {})
+        for key in ("bookmark_bar", "other", "synced"):
+            if key in roots:
+                _walk_chromium_bookmarks(roots[key], out)
+        return out
+    except Exception as e:
+        log.warning(f"Failed to read Bookmarks for {profile.browser}/{profile.name}: {e}")
+        return []
+
+
+def _walk_safari_bookmarks(node: dict, out: list[dict]):
+    """Recursively walk a Safari bookmark plist node."""
+    bm_type = node.get("WebBookmarkType", "")
+    if bm_type == "WebBookmarkTypeLeaf":
+        url = node.get("URLString", "")
+        title = node.get("URIDictionary", {}).get("title", "")
+        if url and not _should_skip(url):
+            out.append({"url": url, "title": title})
+    for child in node.get("Children", []):
+        _walk_safari_bookmarks(child, out)
+
+
+def _safari_bookmarks(profile: BrowserProfile) -> list[dict]:
+    """Read bookmarks from Safari Bookmarks.plist."""
+    bm_path = profile.path / "Bookmarks.plist"
+    if not bm_path.exists():
+        return []
+    try:
+        with open(bm_path, "rb") as f:
+            data = plistlib.load(f)
+        out: list[dict] = []
+        _walk_safari_bookmarks(data, out)
+        return out
+    except Exception as e:
+        log.warning(f"Failed to read Safari Bookmarks.plist: {e}")
+        return []
+
+
+def _firefox_bookmarks(profile: BrowserProfile) -> list[dict]:
+    """Read bookmarks from Firefox places.sqlite."""
+    tmp = copy_db(profile.path / "places.sqlite")
+    if not tmp:
+        return []
+    try:
+        conn = sqlite3.connect(f"file:{tmp}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            "SELECT b.title, p.url FROM moz_bookmarks b "
+            "JOIN moz_places p ON b.fk = p.id "
+            "WHERE b.type = 1"
+        ).fetchall()
+        conn.close()
+        out: list[dict] = []
+        for row in rows:
+            url = row["url"] or ""
+            title = row["title"] or ""
+            if url and not _should_skip(url):
+                out.append({"url": url, "title": title})
+        return out
+    except Exception as e:
+        log.warning(f"Failed to read Firefox bookmarks: {e}")
+        return []
+    finally:
+        shutil.rmtree(tmp.parent, ignore_errors=True)
+
+
+def ingest_bookmarks(mem: MemoryDB, profiles: list[BrowserProfile]):
+    """Extract bookmark memories from all browser profiles."""
+    # Collect all bookmarks across profiles
+    all_bookmarks: list[dict] = []
+    for profile in profiles:
+        if profile.browser in ("arc", "chrome", "brave", "edge"):
+            all_bookmarks.extend(_chromium_bookmarks(profile))
+        elif profile.browser == "safari":
+            all_bookmarks.extend(_safari_bookmarks(profile))
+        elif profile.browser == "firefox":
+            all_bookmarks.extend(_firefox_bookmarks(profile))
+
+    # Deduplicate by URL (keep first title seen)
+    seen_urls: dict[str, str] = {}
+    for bm in all_bookmarks:
+        url = bm["url"]
+        if url not in seen_urls:
+            seen_urls[url] = bm["title"]
+
+    known_count = 0
+    unknown_count = 0
+
+    for url, title in seen_urls.items():
+        d = domain(url)
+        if not d:
+            continue
+
+        if d in SERVICE_NAMES:
+            # Known service: boost the tool entry
+            service = SERVICE_NAMES[d]
+            tags = ["account", "tool"]
+            mem.upsert(f"tool:{service}", title or service, tags, source=f"bookmark:{d}")
+            known_count += 1
+        else:
+            # Unknown domain: create bookmark entry
+            tags = _infer_tags(d)
+            mem.upsert(f"bookmark:{d}", title or d, tags, confidence=0.6, source=f"bookmark:{url}")
+            unknown_count += 1
+
+    log.info(f"  Bookmarks: {len(seen_urls)} unique, {known_count} known services, {unknown_count} new domains")

package/ai_browser_profile/ingestors/browser_detect.py

@@ -0,0 +1,100 @@
+"""Detect installed browsers and their profiles."""
+
+import shutil
+import sqlite3
+import tempfile
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, Set
+from urllib.parse import urlparse
+
+log = logging.getLogger(__name__)
+
+APP_SUPPORT = Path.home() / "Library" / "Application Support"
+
+
+@dataclass
+class BrowserProfile:
+    browser: str  # "arc", "chrome", "safari", "firefox", "brave", "edge"
+    name: str  # "Default", "Profile 1", etc.
+    path: Path  # Full path to the profile directory
+
+
+def _chromium_profiles(browser: str, base: Path) -> list[BrowserProfile]:
+    """Find Chromium-based browser profiles (Default, Profile 1, etc.)."""
+    profiles = []
+    if not base.exists():
+        return profiles
+
+    for d in sorted(base.iterdir()):
+        if d.is_dir() and (d.name == "Default" or d.name.startswith("Profile ")):
+            if (d / "History").exists() or (d / "IndexedDB").exists():
+                profiles.append(BrowserProfile(browser=browser, name=d.name, path=d))
+
+    if not profiles:
+        default = base / "Default"
+        if default.exists():
+            profiles.append(BrowserProfile(browser=browser, name="Default", path=default))
+
+    return profiles
+
+
+def detect_browsers(allowed: Optional[Set[str]] = None) -> list[BrowserProfile]:
+    """Return all detected browser profiles. Optionally filter by browser name."""
+    profiles: list[BrowserProfile] = []
+
+    browsers = {
+        "arc": APP_SUPPORT / "Arc" / "User Data",
+        "chrome": APP_SUPPORT / "Google" / "Chrome",
+        "brave": APP_SUPPORT / "BraveSoftware" / "Brave-Browser",
+        "edge": APP_SUPPORT / "Microsoft Edge",
+    }
+
+    for name, base in browsers.items():
+        if allowed and name not in allowed:
+            continue
+        profiles.extend(_chromium_profiles(name, base))
+
+    # Safari
+    if not allowed or "safari" in allowed:
+        safari_dir = Path.home() / "Library" / "Safari"
+        if safari_dir.exists():
+            profiles.append(BrowserProfile(browser="safari", name="Default", path=safari_dir))
+
+    # Firefox
+    if not allowed or "firefox" in allowed:
+        firefox_base = APP_SUPPORT / "Firefox" / "Profiles"
+        if firefox_base.exists():
+            for d in sorted(firefox_base.iterdir()):
+                if d.is_dir() and (d / "places.sqlite").exists():
+                    profiles.append(BrowserProfile(browser="firefox", name=d.name, path=d))
+
+    log.info(f"Detected {len(profiles)} browser profiles: {[(p.browser, p.name) for p in profiles]}")
+    return profiles
+
+
+def copy_db(src: Path) -> Optional[Path]:
+    """Copy a SQLite DB to temp dir to avoid browser locks."""
+    if not src.exists():
+        return None
+    try:
+        tmp = Path(tempfile.mkdtemp(prefix="ai_browser_profile_"))
+        dst = tmp / src.name
+        shutil.copy2(src, dst)
+        for suffix in ["-wal", "-shm"]:
+            wal = src.parent / (src.name + suffix)
+            if wal.exists():
+                shutil.copy2(wal, tmp / (src.name + suffix))
+        return dst
+    except PermissionError:
+        log.warning(f"Permission denied reading {src} — grant Full Disk Access or skip")
+        return None
+
+
+def domain(url: str) -> str:
+    """Extract domain from URL."""
+    try:
+        return urlparse(url).netloc
+    except Exception:
+        return ""