evolutiondb-notes-sync 0.1.0__py3-none-any.whl

evolutiondb_notes_sync-0.1.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: evolutiondb-notes-sync
+Version: 0.1.0
+Summary: Sync macOS Apple Notes into EvolutionDB long-term memory.
+Author-email: alptekin topal <topal.alptekin@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/alptekin/evolutiondb
+Project-URL: Repository, https://github.com/alptekin/evolutiondb
+Project-URL: Source, https://github.com/alptekin/evolutiondb/tree/main/client/notes-sync
+Project-URL: Issues, https://github.com/alptekin/evolutiondb/issues
+Keywords: evolutiondb,apple-notes,notes,macos,long-term-memory,agent-memory,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.9
+Requires-Dist: psycopg[binary]>=3.1

evolutiondb_notes_sync-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+notes_sync/__init__.py,sha256=8yZmSNOm7ru9akJsY5DCjAdidO1DNzDC1G0Hx8umk1Q,309
+notes_sync/__main__.py,sha256=8Ap-X_Be9dePdOFaAWS6BNHL2kg3FQHkMgQ6Hufk7jg,80
+notes_sync/state.py,sha256=6FyhQkaKpZdkUhAeXeYphP4L5UM2Zvo2miUD6NbXaXk,3906
+notes_sync/sync.py,sha256=ucsw6HAjpc6CyVHUnki2dCpkNRf5z1thF2OwYxnESBw,9131
+evolutiondb_notes_sync-0.1.0.dist-info/METADATA,sha256=K7dXgkbYJNnAZhQIiLOeIgMZJyHTMX9hvsG44GxcC44,1206
+evolutiondb_notes_sync-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+evolutiondb_notes_sync-0.1.0.dist-info/entry_points.txt,sha256=7BtLcAVTqQNBCjERyLKlGu5p363r1CcjijHoJBBSWZU,68
+evolutiondb_notes_sync-0.1.0.dist-info/top_level.txt,sha256=0nZ85TqgUv4qJ9tPTNE6ng0RTvSh1Ny72MNEEBitNyw,11
+evolutiondb_notes_sync-0.1.0.dist-info/RECORD,,

evolutiondb_notes_sync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

evolutiondb_notes_sync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+evolutiondb-notes-sync = notes_sync.__main__:main

evolutiondb_notes_sync-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+notes_sync

notes_sync/__init__.py

@@ -0,0 +1,8 @@
+"""evolutiondb-notes-sync — pull macOS Apple Notes content into
+EvolutionDB long-term memory.
+
+The first run will prompt for Automation permission so this binary
+can talk to Notes.app over the JavaScript-for-Automation bridge.
+That permission persists; subsequent runs are silent."""
+
+__version__ = "0.1.0"

notes_sync/__main__.py

@@ -0,0 +1,4 @@
+from .sync import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

notes_sync/state.py

@@ -0,0 +1,116 @@
+"""Memory backend — mirror of the sibling connector packages."""
+from __future__ import annotations
+
+import json
+import sys
+import time
+from typing import Dict, Optional
+
+
+def _e(s: str) -> str:
+    if not isinstance(s, str):
+        s = str(s)
+    s = s.replace("\r", " ").replace("\n", " ").replace("\t", " ")
+    return s.replace("'", "''")
+
+
+WATERMARK_KEY = "notes_state_latest"
+
+
+def _parse_value(raw):
+    if isinstance(raw, dict):
+        return raw
+    if not raw:
+        return {}
+    try:
+        return json.loads(raw)
+    except (TypeError, ValueError):
+        return {}
+
+
+class MemoryStore:
+    _RECONNECT_ATTEMPTS    = 3
+    _RECONNECT_BACKOFF_SEC = 0.5
+
+    def __init__(self, host: str, port: int, user: str, password: str,
+                 database: str, store: str, namespace: str):
+        try:
+            import psycopg
+        except ImportError as exc:
+            raise RuntimeError(
+                "evolutiondb-notes-sync requires psycopg. Install "
+                "with `pip install psycopg[binary]>=3.1`.") from exc
+
+        self.psycopg = psycopg
+        self._conn_kwargs = dict(
+            host=host, port=port, user=user, password=password,
+            dbname=database, autocommit=True,
+        )
+        self.store     = store
+        self.namespace = namespace
+        self.conn      = self._connect()
+        try:
+            with self.conn.cursor() as cur:
+                cur.execute(f"CREATE MEMORY STORE {self.store}")
+        except Exception:
+            pass
+
+    def _connect(self):
+        return self.psycopg.connect(**self._conn_kwargs)
+
+    def _is_dead(self, exc: BaseException) -> bool:
+        return isinstance(exc, (self.psycopg.OperationalError,
+                                  self.psycopg.InterfaceError))
+
+    def _retry(self, fn):
+        last = None
+        for attempt in range(self._RECONNECT_ATTEMPTS):
+            try:
+                with self.conn.cursor() as cur:
+                    return fn(cur)
+            except Exception as exc:
+                if not self._is_dead(exc):
+                    raise
+                last = exc
+                print(f"[notes-sync] db connection lost "
+                      f"(attempt {attempt + 1}): {exc}",
+                      file=sys.stderr, flush=True)
+                try:
+                    self.conn.close()
+                except Exception:
+                    pass
+                if attempt + 1 < self._RECONNECT_ATTEMPTS:
+                    time.sleep(self._RECONNECT_BACKOFF_SEC *
+                                (attempt + 1))
+                    try:
+                        self.conn = self._connect()
+                    except Exception as reconn:
+                        last = reconn
+                        continue
+        raise last  # type: ignore[misc]
+
+    def get_watermark_iso(self) -> Optional[str]:
+        def run(cur):
+            cur.execute(
+                f"SELECT mem_value FROM __mem_{self.store} "
+                f"WHERE mem_namespace = '{_e(self.namespace)}' "
+                f"AND mem_key = '{_e(WATERMARK_KEY)}'")
+            rows = cur.fetchall()
+            if not rows:
+                return None
+            v = _parse_value(rows[0][0]).get("modified_at")
+            return str(v) if v else None
+        return self._retry(run)
+
+    def set_watermark_iso(self, iso: str) -> None:
+        value = json.dumps({"modified_at": iso,
+                              "saved_at":    time.time()})
+        self._retry(lambda cur: cur.execute(
+            f"MEMORY PUT INTO {self.store} VALUES "
+            f"('{_e(self.namespace)}','{_e(WATERMARK_KEY)}','{_e(value)}')"))
+
+    def put_record(self, key: str, record: Dict) -> None:
+        value = json.dumps(record, ensure_ascii=False)
+        self._retry(lambda cur: cur.execute(
+            f"MEMORY PUT INTO {self.store} VALUES "
+            f"('{_e(self.namespace)}','{_e(key)}','{_e(value)}')"))

notes_sync/sync.py

@@ -0,0 +1,283 @@
+"""
+evolutiondb-notes-sync — talk to Notes.app over JavaScript-for-
+Automation, then store the captured notes in EvolutionDB long-term
+memory.
+
+Why JXA, not the SQLite store?
+------------------------------
+Apple Notes encodes the body of each note as gzip + a private
+NotesBody protobuf inside ZICCLOUDSYNCINGOBJECT.ZDATA in
+NoteStore.sqlite. Reverse-engineering that format is a moving
+target across macOS versions. JXA gives us the rendered HTML body
+straight from Notes.app and never breaks across releases.
+
+Trade-off: the user has to allow Automation in System Settings →
+Privacy & Security → Automation → Terminal/iTerm → Notes. macOS
+prompts for this on first invocation.
+"""
+from __future__ import annotations
+
+import argparse
+import html
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Dict, Iterable, List, Optional
+
+from . import state as state_mod
+
+
+# JXA evaluated by osascript. Emits one JSON object per line so a
+# Python iterator can process notes without holding everything in
+# memory if there are tens of thousands.
+_JXA = r"""
+ObjC.import('Foundation');
+const Notes = Application('Notes');
+Notes.includeStandardAdditions = false;
+
+function isoDate(d) {
+    if (!d) return '';
+    const f = $.NSISO8601DateFormatter.alloc.init;
+    f.formatOptions = $.NSISO8601DateFormatWithInternetDateTime;
+    return ObjC.unwrap(f.stringFromDate(d));
+}
+
+function* iterNotes() {
+    const ns = Notes.notes();
+    for (let i = 0; i < ns.length; i++) {
+        try {
+            const n = ns[i];
+            const folder = (() => {
+                try {
+                    return n.container().name();
+                } catch (e) { return ''; }
+            })();
+            yield {
+                id:       n.id(),
+                name:     n.name(),
+                body:     n.body(),
+                folder:   folder,
+                modified: isoDate(n.modificationDate()),
+                created:  isoDate(n.creationDate()),
+            };
+        } catch (e) {
+            yield {error: String(e)};
+        }
+    }
+}
+
+for (const n of iterNotes()) {
+    console.log(JSON.stringify(n));
+}
+"""
+
+
+def _html_to_text(body_html: str) -> str:
+    """Cheap HTML→text. Apple Notes body uses simple tags
+    (h1/p/div/br/li). We strip tags, decode entities, collapse
+    whitespace, normalise line breaks."""
+    if not body_html:
+        return ""
+    s = body_html
+    s = re.sub(r"</?(?:br|p|div|h[1-6]|li)[^>]*>", "\n", s,
+                flags=re.I)
+    s = re.sub(r"<[^>]+>", " ", s)
+    s = html.unescape(s)
+    s = re.sub(r"[ \t]+", " ", s)
+    s = re.sub(r"\n[ \t]+", "\n", s)
+    s = re.sub(r"\n{3,}", "\n\n", s)
+    return s.strip()
+
+
+def iter_notes() -> Iterable[Dict]:
+    """Spawn osascript and stream JSON notes line by line."""
+    try:
+        proc = subprocess.Popen(
+            ["/usr/bin/osascript", "-l", "JavaScript", "-e", _JXA],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+            text=True, bufsize=1)
+    except FileNotFoundError:
+        print("[notes-sync] /usr/bin/osascript not found — Notes "
+              "sync is macOS-only.", file=sys.stderr, flush=True)
+        return
+
+    assert proc.stdout is not None
+    try:
+        for line in proc.stdout:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if "error" in obj:
+                print(f"[notes-sync] note skipped: {obj['error']}",
+                      file=sys.stderr, flush=True)
+                continue
+            yield obj
+    finally:
+        try:
+            proc.stdout.close()
+        except Exception:
+            pass
+        rc = proc.wait(timeout=600)
+        if rc != 0 and proc.stderr is not None:
+            err = proc.stderr.read().strip()
+            if err:
+                print(f"[notes-sync] osascript stderr: {err[:400]}",
+                      file=sys.stderr, flush=True)
+
+
+# ---------------------------------------------------------------- #
+def _load_dotenv(path: Path) -> None:
+    if not path.exists():
+        return
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        k, v = k.strip(), v.strip().strip('"').strip("'")
+        if v:
+            os.environ.setdefault(k, v)
+
+
+class Config:
+    def __init__(self):
+        self.evosql_host = os.environ.get("EVOSQL_HOST",     "127.0.0.1")
+        self.evosql_port = int(os.environ.get("EVOSQL_PORT", "5433"))
+        self.evosql_user = os.environ.get("EVOSQL_USER",     "admin")
+        self.evosql_pass = os.environ.get("EVOSQL_PASSWORD", "admin")
+        self.evosql_db   = os.environ.get("EVOSQL_DATABASE", "evosql")
+        self.user_id     = os.environ.get("MCP_USER_ID",
+                                            "default_user")
+        self.store       = os.environ.get("NOTES_MEMORY_STORE",
+                                            "mcp_mem")
+
+
+def _build_record(n: Dict) -> Optional[Dict]:
+    title = (n.get("name") or "").strip() or "(untitled)"
+    text  = _html_to_text(n.get("body") or "")
+    if not text and title == "(untitled)":
+        return None
+    modified = n.get("modified") or n.get("created") or ""
+    return {
+        "fact":         f"Note \"{title}\": {text[:240]}",
+        "source":       "notes",
+        "kind":         "note",
+        "title":        title,
+        "text":         text,
+        "folder":       n.get("folder") or "",
+        "note_id":      n.get("id") or "",
+        "modified_at":  modified,
+        "created_at":   n.get("created") or "",
+        "tags":         ["notes", "apple-notes"],
+    }
+
+
+def _note_key(n: Dict) -> str:
+    raw_id = (n.get("note_id") or "").replace("/", "_")
+    return f"note_{raw_id}"
+
+
+def sync_once(cfg: Config, *, since_iso: Optional[str],
+                dry_run: bool = False) -> Dict[str, int]:
+    counters = {"notes": 0, "skipped": 0, "errors": 0}
+    store: Optional[state_mod.MemoryStore] = None
+    if not dry_run:
+        store = state_mod.MemoryStore(
+            host=cfg.evosql_host, port=cfg.evosql_port,
+            user=cfg.evosql_user, password=cfg.evosql_pass,
+            database=cfg.evosql_db, store=cfg.store,
+            namespace=cfg.user_id,
+        )
+
+    wm = (store.get_watermark_iso() if store else None)
+    floor = wm or since_iso
+    highest = floor or ""
+
+    try:
+        for raw in iter_notes():
+            rec = _build_record(raw)
+            if not rec:
+                counters["skipped"] += 1
+                continue
+            if floor and rec["modified_at"] <= floor:
+                continue
+            if store:
+                store.put_record(_note_key(rec), rec)
+            counters["notes"] += 1
+            if rec["modified_at"] > highest:
+                highest = rec["modified_at"]
+    except Exception as exc:  # noqa: BLE001
+        print(f"[notes-sync] read failed: {exc}",
+              file=sys.stderr, flush=True)
+        counters["errors"] += 1
+
+    if store and highest and highest != (wm or ""):
+        store.set_watermark_iso(highest)
+    return counters
+
+
+_stop = False
+
+
+def _install_signal_handlers() -> None:
+    def _handler(_signum, _frame):
+        global _stop
+        _stop = True
+        print("[notes-sync] stop requested",
+              file=sys.stderr, flush=True)
+    for s in (signal.SIGTERM, signal.SIGINT):
+        try:
+            signal.signal(s, _handler)
+        except (ValueError, OSError):
+            pass
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = argparse.ArgumentParser(prog="evolutiondb-notes-sync",
+        description="Sync macOS Apple Notes into EvolutionDB.")
+    parser.add_argument("--once",     action="store_true")
+    parser.add_argument("--interval", type=int)
+    parser.add_argument("--since",
+        default="",
+        help="Optional ISO floor for first run (e.g. 2026-01-01T00:00:00Z). "
+             "Empty means import everything.")
+    parser.add_argument("--dry-run",  action="store_true")
+    parser.add_argument("--env-file", default=".env")
+    args = parser.parse_args(argv)
+
+    _load_dotenv(Path(args.env_file).expanduser())
+    cfg = Config()
+    _install_signal_handlers()
+
+    def run_pass() -> int:
+        try:
+            counts = sync_once(cfg, since_iso=args.since or None,
+                                 dry_run=args.dry_run)
+            print(json.dumps({"ok": True, **counts}), flush=True)
+            return 0
+        except Exception as exc:  # noqa: BLE001
+            print(json.dumps({"ok": False, "error": str(exc)}),
+                  flush=True)
+            return 4
+
+    if args.once or not args.interval:
+        return run_pass()
+
+    interval = max(60, int(args.interval))
+    rc = 0
+    while not _stop:
+        rc = run_pass()
+        for _ in range(interval):
+            if _stop:
+                break
+            time.sleep(1)
+    return rc