bearcli 1.0.0__py3-none-any.whl

bearcli/db.py

@@ -0,0 +1,260 @@
+"""Read-only access to Bear's SQLite database."""
+
+from __future__ import annotations
+
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+
+DEFAULT_DB_PATH = (
+    Path.home() / "Library/Group Containers/9K33E3U3T4.net.shinyfrog.bear" / "Application Data/database.sqlite"
+)
+
+# Core Data stores timestamps as seconds since 2001-01-01 UTC.
+CORE_DATA_EPOCH = datetime(2001, 1, 1, tzinfo=UTC)
+
+
+def core_data_to_datetime(value: float | None) -> datetime | None:
+    if value is None:
+        return None
+    return (CORE_DATA_EPOCH + timedelta(seconds=value)).astimezone()
+
+
+def datetime_to_core_data(value: datetime) -> float:
+    if value.tzinfo is None:
+        value = value.astimezone()
+    return (value - CORE_DATA_EPOCH).total_seconds()
+
+
+@dataclass
+class Attachment:
+    id: str
+    filename: str
+    path: Path
+    size: int | None
+    exists: bool
+
+
+@dataclass
+class Note:
+    id: str
+    title: str
+    created: datetime | None
+    modified: datetime | None
+    pinned: bool
+    encrypted: bool
+    archived: bool
+    trashed: bool
+    tags: list[str] = field(default_factory=list)
+    text: str | None = None
+    attachments: list[Attachment] = field(default_factory=list)
+
+
+class BearDB:
+    def __init__(self, path: Path = DEFAULT_DB_PATH):
+        if not path.exists():
+            raise FileNotFoundError(f"Bear database not found at {path}")
+        self.conn = sqlite3.connect(f"file:{path}?mode=ro", uri=True)
+        self.conn.row_factory = sqlite3.Row
+        self.files_dir = path.parent / "Local Files"
+        self._tags_join = self._detect_tags_join()
+
+    def close(self) -> None:
+        self.conn.close()
+
+    def _detect_tags_join(self) -> tuple[str, str, str]:
+        """Find the note<->tag join table; its numeric prefixes vary by Bear version.
+
+        Returns (table, note_column, tag_column).
+        """
+        rows = self.conn.execute(
+            "SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'Z\\_%TAGS' ESCAPE '\\'"
+        ).fetchall()
+        for (table,) in rows:
+            if not re.fullmatch(r"Z_\d+TAGS", table):
+                continue
+            columns = [r["name"] for r in self.conn.execute(f"PRAGMA table_info({table})")]
+            note_col = next((c for c in columns if re.fullmatch(r"Z_\d+NOTES", c)), None)
+            tag_col = next((c for c in columns if re.fullmatch(r"Z_\d+TAGS", c)), None)
+            if note_col and tag_col:
+                return table, note_col, tag_col
+        raise RuntimeError("Could not locate the note/tag join table in the Bear database")
+
+    def _tags_for_note(self, note_pk: int) -> list[str]:
+        table, note_col, tag_col = self._tags_join
+        rows = self.conn.execute(
+            f"""
+            SELECT t.ZTITLE FROM ZSFNOTETAG t
+            JOIN {table} j ON j.{tag_col} = t.Z_PK
+            WHERE j.{note_col} = ?
+            ORDER BY t.ZTITLE
+            """,
+            (note_pk,),
+        ).fetchall()
+        return [r["ZTITLE"] for r in rows]
+
+    def list_tags(self, include_empty: bool = False) -> list[tuple[str, int]]:
+        """All tags with their note counts (excluding trashed/deleted notes).
+
+        Bear keeps tag rows around after their last note is untagged (the app
+        hides them), so empty tags are excluded unless include_empty is set.
+        """
+        table, note_col, tag_col = self._tags_join
+        having = "" if include_empty else "HAVING COUNT(n.Z_PK) > 0"
+        rows = self.conn.execute(
+            f"""
+            SELECT t.ZTITLE, COUNT(n.Z_PK)
+            FROM ZSFNOTETAG t
+            LEFT JOIN {table} j ON j.{tag_col} = t.Z_PK
+            LEFT JOIN ZSFNOTE n
+                ON n.Z_PK = j.{note_col} AND n.ZTRASHED = 0 AND n.ZPERMANENTLYDELETED = 0
+            GROUP BY t.Z_PK
+            {having}
+            ORDER BY t.ZTITLE
+            """
+        ).fetchall()
+        return [(row[0], row[1]) for row in rows]
+
+    def _attachments_for_note(self, note_pk: int) -> list[Attachment]:
+        rows = self.conn.execute(
+            """
+            SELECT ZUNIQUEIDENTIFIER, ZFILENAME, ZFILESIZE FROM ZSFNOTEFILE
+            WHERE ZNOTE = ? AND ZPERMANENTLYDELETED = 0 ORDER BY ZFILENAME
+            """,
+            (note_pk,),
+        ).fetchall()
+        attachments = []
+        for row in rows:
+            # Images live under "Note Images", everything else under "Note Files";
+            # the database doesn't record which, so probe both.
+            candidates = [
+                self.files_dir / subdir / row["ZUNIQUEIDENTIFIER"] / row["ZFILENAME"]
+                for subdir in ("Note Images", "Note Files")
+            ]
+            path = next((c for c in candidates if c.exists()), candidates[0])
+            attachments.append(
+                Attachment(
+                    id=row["ZUNIQUEIDENTIFIER"],
+                    filename=row["ZFILENAME"],
+                    path=path,
+                    size=row["ZFILESIZE"],
+                    exists=path.exists(),
+                )
+            )
+        return attachments
+
+    def list_notes(
+        self,
+        limit: int | None = None,
+        tag: str | None = None,
+        created_after: datetime | None = None,
+        created_before: datetime | None = None,
+        modified_after: datetime | None = None,
+        modified_before: datetime | None = None,
+        only: str | None = None,
+        include_trashed: bool = False,
+        include_archived: bool = False,
+        with_text: bool = False,
+    ) -> list[Note]:
+        table, note_col, tag_col = self._tags_join
+        # Deleted-pending-sync rows linger in the table; never show them.
+        where = ["n.ZPERMANENTLYDELETED = 0"]
+        params: list[object] = []
+
+        if only == "pinned":
+            where.append("n.ZPINNED = 1")
+        elif only == "encrypted":
+            where.append("n.ZENCRYPTED = 1")
+
+        if only == "trashed":
+            where.append("n.ZTRASHED = 1")
+        elif not include_trashed:
+            where.append("n.ZTRASHED = 0")
+        if only == "archived":
+            where.append("n.ZARCHIVED = 1")
+        elif not include_archived and only != "trashed":
+            # A note trashed from the archive keeps both flags; Bear shows it in
+            # the trash, so --only trashed must not exclude archived notes.
+            where.append("n.ZARCHIVED = 0")
+        if tag:
+            # Match the tag itself and its nested sub-tags (e.g. "work" matches "work/ideas").
+            where.append(
+                f"""n.Z_PK IN (
+                    SELECT j.{note_col} FROM {table} j
+                    JOIN ZSFNOTETAG t ON t.Z_PK = j.{tag_col}
+                    WHERE t.ZTITLE = ? OR t.ZTITLE LIKE ? ESCAPE '\\'
+                )"""
+            )
+            escaped = tag.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+            params += [tag, f"{escaped}/%"]
+        if created_after:
+            where.append("n.ZCREATIONDATE >= ?")
+            params.append(datetime_to_core_data(created_after))
+        if created_before:
+            where.append("n.ZCREATIONDATE < ?")
+            params.append(datetime_to_core_data(created_before))
+        if modified_after:
+            where.append("n.ZMODIFICATIONDATE >= ?")
+            params.append(datetime_to_core_data(modified_after))
+        if modified_before:
+            where.append("n.ZMODIFICATIONDATE < ?")
+            params.append(datetime_to_core_data(modified_before))
+
+        text_col = ", n.ZTEXT" if with_text else ""
+        query = f"""
+            SELECT n.Z_PK, n.ZUNIQUEIDENTIFIER, n.ZTITLE, n.ZCREATIONDATE,
+                   n.ZMODIFICATIONDATE, n.ZPINNED, n.ZENCRYPTED, n.ZARCHIVED, n.ZTRASHED{text_col}
+            FROM ZSFNOTE n
+        """
+        if where:
+            query += " WHERE " + " AND ".join(where)
+        query += " ORDER BY n.ZMODIFICATIONDATE DESC"
+        if limit is not None:
+            query += " LIMIT ?"
+            params.append(limit)
+
+        notes = []
+        for row in self.conn.execute(query, params):
+            notes.append(
+                Note(
+                    id=row["ZUNIQUEIDENTIFIER"],
+                    title=row["ZTITLE"] or "(untitled)",
+                    created=core_data_to_datetime(row["ZCREATIONDATE"]),
+                    modified=core_data_to_datetime(row["ZMODIFICATIONDATE"]),
+                    pinned=bool(row["ZPINNED"]),
+                    encrypted=bool(row["ZENCRYPTED"]),
+                    archived=bool(row["ZARCHIVED"]),
+                    trashed=bool(row["ZTRASHED"]),
+                    tags=self._tags_for_note(row["Z_PK"]),
+                    text=row["ZTEXT"] if with_text else None,
+                )
+            )
+        return notes
+
+    def get_note(self, note_id: str) -> Note | None:
+        row = self.conn.execute(
+            """
+            SELECT Z_PK, ZUNIQUEIDENTIFIER, ZTITLE, ZTEXT, ZCREATIONDATE,
+                   ZMODIFICATIONDATE, ZPINNED, ZENCRYPTED, ZARCHIVED, ZTRASHED
+            FROM ZSFNOTE
+            WHERE ZUNIQUEIDENTIFIER = ? COLLATE NOCASE
+            """,
+            (note_id,),
+        ).fetchone()
+        if row is None:
+            return None
+        return Note(
+            id=row["ZUNIQUEIDENTIFIER"],
+            title=row["ZTITLE"] or "(untitled)",
+            created=core_data_to_datetime(row["ZCREATIONDATE"]),
+            modified=core_data_to_datetime(row["ZMODIFICATIONDATE"]),
+            pinned=bool(row["ZPINNED"]),
+            encrypted=bool(row["ZENCRYPTED"]),
+            archived=bool(row["ZARCHIVED"]),
+            trashed=bool(row["ZTRASHED"]),
+            tags=self._tags_for_note(row["Z_PK"]),
+            text=row["ZTEXT"],
+            attachments=self._attachments_for_note(row["Z_PK"]),
+        )

bearcli/export.py

@@ -0,0 +1,250 @@
+"""Export Bear notes to self-contained per-note directories."""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from collections import Counter
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import quote
+
+from bearcli.db import BearDB, Note
+
+NOTE_FILENAME = "README.md"
+ATTACHMENTS_DIRNAME = "attachments"
+
+
+@dataclass
+class ExportResult:
+    written: int = 0
+    unchanged: int = 0
+    removed: int = 0
+    skipped_encrypted: int = 0
+    index_updated: bool = False
+    index_skipped: bool = False
+
+
+def slugify(title: str, max_length: int = 60) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+    return slug[:max_length].rstrip("-") or "untitled"
+
+
+def _dirnames(notes: list[Note]) -> dict[str, str]:
+    """Map note id -> directory name: <slug>-<first 8 id chars>.
+
+    The id fragment makes names unique without title-dedup suffixes. In the
+    astronomically rare case two notes share both slug and id prefix, those
+    notes use their full id so the outcome never depends on iteration order.
+    """
+    short = {n.id: f"{slugify(n.title)}-{n.id[:8].lower()}" for n in notes}
+    counts = Counter(short.values())
+    return {n.id: short[n.id] if counts[short[n.id]] == 1 else f"{slugify(n.title)}-{n.id.lower()}" for n in notes}
+
+
+def _frontmatter(note: Note) -> str:
+    lines = [
+        "---",
+        f"id: {note.id}",
+        f"title: {json.dumps(note.title, ensure_ascii=False)}",
+        f"tags: [{', '.join(note.tags)}]",
+    ]
+    if note.created:
+        lines.append(f"created: {note.created.isoformat()}")
+    if note.modified:
+        lines.append(f"modified: {note.modified.isoformat()}")
+    lines.append("---")
+    return "\n".join(lines)
+
+
+def _parse_frontmatter(path: Path) -> dict[str, str]:
+    fields: dict[str, str] = {}
+    try:
+        with path.open() as fh:
+            if fh.readline().rstrip("\n") != "---":
+                return fields
+            for line in fh:
+                line = line.rstrip("\n")
+                if line == "---":
+                    break
+                key, _, value = line.partition(": ")
+                fields[key] = value
+    except OSError:
+        pass
+    return fields
+
+
+INDEX_MARKER = "generated-by: bearcli"
+
+
+def _entry_flags(entry: dict) -> str:
+    flags = ""
+    if entry["attachments"]:
+        flags += "📎"
+    if entry["encrypted"]:
+        flags += "🔒"
+    if entry["archived"]:
+        flags += "🗄"
+    return flags
+
+
+def _index_rows(entries: list[dict]) -> list[str]:
+    rows = ["| Note | Tags | Modified | |", "|---|---|---|---|"]
+    for e in entries:
+        title = e["title"].replace("|", "\\|")
+        link = f"[{title}]({e['path']})" if e["path"] else title
+        modified = (e["modified"] or "")[:10]
+        rows.append(f"| {link} | {', '.join(e['tags'])} | {modified} | {_entry_flags(e)} |")
+    return rows
+
+
+def _index_markdown(entries: list[dict]) -> str:
+    entries = sorted(entries, key=lambda e: e["modified"] or "", reverse=True)
+    lines = [
+        "---",
+        INDEX_MARKER,
+        "---",
+        "",
+        "# Bear notes",
+        "",
+        f"{len(entries)} notes · 📎 attachments · 🔒 encrypted · 🗄 archived",
+        "",
+    ]
+    pinned = [e for e in entries if e["pinned"]]
+    if pinned:
+        lines += ["## 📌 Pinned", ""] + _index_rows(pinned) + [""]
+    rest = [e for e in entries if not e["pinned"]]
+    by_year: dict[str, list[dict]] = {}
+    for e in rest:
+        year = e["modified"][:4] if e["modified"] else "Undated"
+        by_year.setdefault(year, []).append(e)
+    for year in sorted(by_year, reverse=True):
+        lines += [f"## {year}", ""] + _index_rows(by_year[year]) + [""]
+    return "\n".join(lines)
+
+
+def _write_if_changed(path: Path, content: str) -> bool:
+    try:
+        if path.read_text() == content:
+            return False
+    except OSError:
+        pass
+    path.write_text(content)
+    return True
+
+
+def _rewrite_refs(note: Note) -> str:
+    text = note.text or ""
+    for att in note.attachments:
+        target = quote(f"{ATTACHMENTS_DIRNAME}/{att.filename}")
+        for ref in {att.filename, quote(att.filename)}:
+            text = text.replace(f"]({ref})", f"]({target})")
+    return text
+
+
+def export_notes(
+    db: BearDB,
+    dest: Path,
+    sync: bool = False,
+    progress: Callable[[str], None] | None = None,
+) -> ExportResult:
+    """Write every non-trashed note as dest/<slug>/README.md plus attachments/.
+
+    With sync=True, notes whose id and modified timestamp match the existing
+    README's frontmatter are left untouched. In both modes, directories for
+    notes that no longer exist (or whose title changed slug) are removed; only
+    directories whose README carries an `id:` frontmatter field are ever touched.
+    """
+    dest.mkdir(parents=True, exist_ok=True)
+    result = ExportResult()
+
+    def report(message: str) -> None:
+        if progress is not None:
+            progress(message)
+
+    report("Reading notes from Bear…")
+    summaries = db.list_notes(limit=None, include_archived=True)
+    dirnames = _dirnames(summaries)
+
+    entries: list[dict] = []
+
+    def add_entry(note: Note, path: str | None, attachments: bool) -> None:
+        entries.append(
+            {
+                "id": note.id,
+                "title": note.title,
+                "path": path,
+                "tags": note.tags,
+                "created": note.created.isoformat() if note.created else None,
+                "modified": note.modified.isoformat() if note.modified else None,
+                "pinned": note.pinned,
+                "encrypted": note.encrypted,
+                "archived": note.archived,
+                "attachments": attachments,
+            }
+        )
+
+    for position, summary in enumerate(summaries, start=1):
+        report(f"[{position}/{len(summaries)}] {summary.title}")
+        if summary.encrypted:
+            result.skipped_encrypted += 1
+            add_entry(summary, None, False)
+            continue
+
+        slug = dirnames[summary.id]
+        note_dir = dest / slug
+        note_path = note_dir / NOTE_FILENAME
+
+        modified_iso = summary.modified.isoformat() if summary.modified else ""
+        if sync and note_path.exists():
+            existing = _parse_frontmatter(note_path)
+            if existing.get("id") == summary.id and existing.get("modified") == modified_iso:
+                result.unchanged += 1
+                add_entry(summary, f"{slug}/", (note_dir / ATTACHMENTS_DIRNAME).exists())
+                continue
+
+        note = db.get_note(summary.id)
+        if note is None or note.text is None:
+            result.skipped_encrypted += 1
+            add_entry(summary, None, False)
+            continue
+
+        note_dir.mkdir(exist_ok=True)
+        note_path.write_text(f"{_frontmatter(note)}\n{_rewrite_refs(note)}\n")
+
+        attach_dir = note_dir / ATTACHMENTS_DIRNAME
+        if attach_dir.exists():
+            shutil.rmtree(attach_dir)
+        for att in note.attachments:
+            if not att.exists:
+                continue
+            attach_dir.mkdir(exist_ok=True)
+            shutil.copy2(att.path, attach_dir / att.filename)
+        result.written += 1
+        add_entry(note, f"{slug}/", attach_dir.exists())
+
+    # Remove directories for notes that were deleted in Bear or whose slug changed.
+    report("Cleaning up removed notes…")
+    current_dirs = set(dirnames.values())
+    for stale in dest.iterdir():
+        if not stale.is_dir() or stale.name in current_dirs:
+            continue
+        if not _parse_frontmatter(stale / NOTE_FILENAME).get("id"):
+            continue
+        shutil.rmtree(stale)
+        result.removed += 1
+
+    report("Writing index…")
+    index_path = dest / "README.md"
+    if index_path.exists() and _parse_frontmatter(index_path).get("generated-by") != "bearcli":
+        result.index_skipped = True
+    else:
+        result.index_updated = _write_if_changed(index_path, _index_markdown(entries))
+    result.index_updated |= _write_if_changed(
+        dest / "index.json",
+        json.dumps(sorted(entries, key=lambda e: e["title"].lower()), indent=2, ensure_ascii=False) + "\n",
+    )
+
+    return result

bearcli/search.py

@@ -0,0 +1,121 @@
+"""Fuzzy search over notes using rapidfuzz."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from rapidfuzz import fuzz, utils
+
+from bearcli.db import Note
+
+# Where the match landed determines its weight: a title hit beats an equally
+# good tag hit, which beats a body hit.
+TITLE_WEIGHT = 1.0
+TAG_WEIGHT = 0.95
+BODY_WEIGHT = 0.9
+
+SNIPPET_LENGTH = 70
+
+
+@dataclass
+class SearchResult:
+    note: Note
+    snippet: str
+    score: float | None = None  # None for naive (substring) matches
+
+
+def naive_search(notes: list[Note], query: str) -> list[SearchResult]:
+    """Case-insensitive substring search over titles, tags, and text.
+
+    Input order (most recently modified first) is preserved.
+    """
+    needle = query.lower()
+    results = []
+    for note in notes:
+        title_hit = needle in note.title.lower()
+        tag_hit = any(needle in tag.lower() for tag in note.tags)
+        body_line = next(
+            (line.strip() for line in (note.text or "").splitlines() if needle in line.lower()),
+            "",
+        )
+        if not (title_hit or tag_hit or body_line):
+            continue
+        snippet = _trim_snippet(body_line, query) if body_line and not (title_hit or tag_hit) else ""
+        results.append(SearchResult(note=note, snippet=snippet))
+    return results
+
+
+def _fuzzy_score(processed_query: str, target: str) -> float:
+    """Direction-aware scoring: the query must always be the needle.
+
+    partial_ratio slides the shorter string over the longer one, so a trivially
+    short target ("Bindi") would score ~80 against a long query. Only allow the
+    sliding when the target is at least query-sized; otherwise use plain ratio,
+    which penalizes the missing content.
+    """
+    processed_target = utils.default_process(target)
+    if not processed_query or not processed_target:
+        return 0.0
+    if len(processed_target) >= len(processed_query):
+        return fuzz.partial_ratio(processed_query, processed_target)
+    return fuzz.ratio(processed_query, processed_target)
+
+
+def _body_match(query: str, text: str | None) -> tuple[float, str]:
+    """Score the query against the full note text; return (score, matching line).
+
+    partial_ratio must slide the query over the text, never the reverse: with a
+    short haystack the needle/haystack roles flip and trivial strings score ~90.
+    """
+    processed_query = utils.default_process(query)
+    processed_text = utils.default_process(text or "")
+    if not processed_query or not processed_text:
+        return 0.0, ""
+    if len(processed_text) < len(processed_query):
+        return fuzz.ratio(processed_query, processed_text), (text or "").strip().splitlines()[0]
+
+    alignment = fuzz.partial_ratio_alignment(processed_query, processed_text)
+    if alignment is None:
+        return 0.0, ""
+    # default_process keeps positions 1:1 (non-alnum become spaces) except for
+    # the leading strip, so shift by where the first alphanumeric char was.
+    first_alnum = re.search(r"[^\W_]", text or "")
+    pos = alignment.dest_start + (first_alnum.start() if first_alnum else 0)
+    line_start = (text or "").rfind("\n", 0, pos) + 1
+    line_end = (text or "").find("\n", pos)
+    line = (text or "")[line_start : line_end if line_end >= 0 else None].strip()
+    return alignment.score, line
+
+
+def _trim_snippet(line: str, query: str) -> str:
+    if len(line) <= SNIPPET_LENGTH:
+        return line
+    # Center the snippet on the first query word that occurs literally, if any.
+    lowered = line.lower()
+    pos = next((p for w in query.lower().split() if (p := lowered.find(w)) >= 0), 0)
+    start = max(0, min(pos - SNIPPET_LENGTH // 3, len(line) - SNIPPET_LENGTH))
+    end = start + SNIPPET_LENGTH
+    prefix = "…" if start > 0 else ""
+    suffix = "…" if end < len(line) else ""
+    return f"{prefix}{line[start:end].strip()}{suffix}"
+
+
+def search_notes(notes: list[Note], query: str, min_score: float = 60.0) -> list[SearchResult]:
+    """Score every note against the query; return matches sorted best-first."""
+    processed_query = utils.default_process(query)
+    results = []
+    for note in notes:
+        title_score = _fuzzy_score(processed_query, note.title) * TITLE_WEIGHT
+        tag_score = max(_fuzzy_score(processed_query, tag) for tag in note.tags) * TAG_WEIGHT if note.tags else 0.0
+        body_raw, body_line = _body_match(query, note.text)
+        body_score = body_raw * BODY_WEIGHT
+
+        score = max(title_score, tag_score, body_score)
+        if score < min_score:
+            continue
+        snippet = _trim_snippet(body_line, query) if body_score >= max(title_score, tag_score) else ""
+        results.append(SearchResult(note=note, score=score, snippet=snippet))
+
+    results.sort(key=lambda r: r.score or 0.0, reverse=True)
+    return results