omnimem 0.1.0

package/README.md

@@ -0,0 +1,89 @@
+# OmniMem
+
+OmniMem is reusable, low-coupling memory infrastructure for AI agents across tools, devices, projects, and accounts.
+
+Current status: `Phase D implemented (WebUI + auto sync daemon + bootstrap + uninstall)`
+
+## Goals
+
+- Cross-tool: same behavior via CLI protocol (Claude Code / Codex / Cursor).
+- Cross-device: sync through a private Git repository.
+- Cross-project: reusable memory patterns and references.
+- Low-coupling: attach/remove with minimal project files.
+- Human + machine views: Markdown + JSONL + SQLite FTS.
+- Security: never store secrets in memory body, only credential references.
+
+## Structure
+
+- `omnimem/`: core CLI and WebUI implementation.
+- `bin/omnimem`: launcher.
+- `scripts/`: install, bootstrap, attach, detach, verify helpers.
+- `templates/project-minimal/`: minimal project integration files.
+- `spec/`: protocol and schemas.
+- `db/schema.sql`: SQLite + FTS schema.
+- `docs/`: architecture and operations docs.
+
+## One-command usage
+
+Start app (WebUI + daemon):
+
+```bash
+~/.omnimem/bin/omnimem
+```
+
+Optional host/port:
+
+```bash
+~/.omnimem/bin/omnimem --host 127.0.0.1 --port 8765
+```
+
+## Install
+
+Local install from repo:
+
+```bash
+bash scripts/install.sh
+```
+
+Bootstrap on a new device:
+
+```bash
+bash scripts/bootstrap.sh --repo <your-omnimem-repo-url>
+```
+
+## Project attach/remove
+
+```bash
+bash scripts/attach_project.sh /path/to/project my-project-id
+bash scripts/detach_project.sh /path/to/project
+```
+
+## Uninstall
+
+```bash
+~/.omnimem/bin/omnimem uninstall --yes
+```
+
+## Publish and npx
+
+After publishing to npm, end users can run:
+
+```bash
+npx -y omnimem
+```
+
+## Verification
+
+```bash
+bash scripts/verify_phase_a.sh
+bash scripts/verify_phase_b.sh
+bash scripts/verify_phase_c.sh
+bash scripts/verify_phase_d.sh
+```
+
+## Docs
+
+- `docs/quickstart-10min.md`
+- `docs/webui-config.md`
+- `docs/publish-npm.md`
+- `docs/install-uninstall.md`

package/bin/omnimem

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+PYTHONPATH="$ROOT_DIR${PYTHONPATH:+:$PYTHONPATH}" exec python3 -m omnimem.cli "$@"

package/db/schema.sql

@@ -0,0 +1,78 @@
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS memories (
+  id TEXT PRIMARY KEY,
+  schema_version TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  layer TEXT NOT NULL CHECK (layer IN ('instant', 'short', 'long', 'archive')),
+  kind TEXT NOT NULL CHECK (kind IN ('note', 'decision', 'task', 'checkpoint', 'summary', 'evidence')),
+  summary TEXT NOT NULL,
+  body_md_path TEXT NOT NULL,
+  body_text TEXT NOT NULL DEFAULT '',
+  tags_json TEXT NOT NULL DEFAULT '[]',
+  importance_score REAL NOT NULL DEFAULT 0.5 CHECK (importance_score >= 0 AND importance_score <= 1),
+  confidence_score REAL NOT NULL DEFAULT 0.5 CHECK (confidence_score >= 0 AND confidence_score <= 1),
+  stability_score REAL NOT NULL DEFAULT 0.5 CHECK (stability_score >= 0 AND stability_score <= 1),
+  reuse_count INTEGER NOT NULL DEFAULT 0 CHECK (reuse_count >= 0),
+  volatility_score REAL NOT NULL DEFAULT 0.5 CHECK (volatility_score >= 0 AND volatility_score <= 1),
+  cred_refs_json TEXT NOT NULL DEFAULT '[]',
+  source_json TEXT NOT NULL,
+  scope_json TEXT NOT NULL,
+  integrity_json TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_memories_layer ON memories(layer);
+CREATE INDEX IF NOT EXISTS idx_memories_kind ON memories(kind);
+CREATE INDEX IF NOT EXISTS idx_memories_updated_at ON memories(updated_at);
+CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance_score);
+CREATE INDEX IF NOT EXISTS idx_memories_reuse_count ON memories(reuse_count);
+
+CREATE TABLE IF NOT EXISTS memory_refs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  memory_id TEXT NOT NULL,
+  ref_type TEXT NOT NULL,
+  target TEXT NOT NULL,
+  note TEXT,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_refs_memory_id ON memory_refs(memory_id);
+CREATE INDEX IF NOT EXISTS idx_memory_refs_target ON memory_refs(target);
+
+CREATE TABLE IF NOT EXISTS memory_events (
+  event_id TEXT PRIMARY KEY,
+  event_type TEXT NOT NULL,
+  event_time TEXT NOT NULL,
+  memory_id TEXT NOT NULL,
+  payload_json TEXT NOT NULL,
+  FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_memory_events_type_time ON memory_events(event_type, event_time);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+  id UNINDEXED,
+  summary,
+  body_text,
+  tags,
+  tokenize = 'unicode61'
+);
+
+CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories
+BEGIN
+  INSERT INTO memories_fts(id, summary, body_text, tags)
+  VALUES (new.id, new.summary, new.body_text, new.tags_json);
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories
+BEGIN
+  DELETE FROM memories_fts WHERE id = old.id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories
+BEGIN
+  DELETE FROM memories_fts WHERE id = old.id;
+  INSERT INTO memories_fts(id, summary, body_text, tags)
+  VALUES (new.id, new.summary, new.body_text, new.tags_json);
+END;

package/docs/quickstart-10min.md

@@ -0,0 +1,35 @@
+# Quickstart (10 minutes)
+
+## New device
+
+After npm publish:
+
+```bash
+npx -y omnimem
+```
+
+Without npm publish yet:
+
+```bash
+bash scripts/bootstrap.sh --repo <your-omnimem-repo-url>
+```
+
+## Open UI
+
+```bash
+~/.omnimem/bin/omnimem --host 127.0.0.1 --port 8765
+```
+
+Open `http://127.0.0.1:8765`.
+
+## New project
+
+```bash
+~/.omnimem/app/scripts/attach_project.sh /path/to/project my-project-id
+```
+
+## Remove
+
+```bash
+~/.omnimem/bin/omnimem uninstall --yes
+```

package/omnimem/__init__.py

@@ -0,0 +1,2 @@
+__all__ = ["__version__"]
+__version__ = "0.1.0"

package/omnimem/adapters.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+NOTION_API_BASE = "https://api.notion.com/v1"
+NOTION_VERSION = "2022-06-28"
+
+
+def resolve_cred_ref(ref: str) -> str:
+    if ref.startswith("env://"):
+        key = ref[len("env://") :]
+        val = os.getenv(key)
+        if val is None:
+            raise ValueError(f"environment variable not found: {key}")
+        return val
+
+    if ref.startswith("op://"):
+        proc = subprocess.run(["op", "read", ref], check=True, capture_output=True, text=True)
+        return proc.stdout.strip()
+
+    raise ValueError("unsupported cred ref, expected env:// or op://")
+
+
+def _http_json(method: str, url: str, headers: dict[str, str], payload: dict[str, Any] | None = None) -> dict[str, Any]:
+    data = None
+    if payload is not None:
+        data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url=url, method=method, headers=headers, data=data)
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"http {exc.code}: {body}") from exc
+
+
+def notion_write_page(
+    *,
+    token: str,
+    database_id: str,
+    title: str,
+    content: str,
+    title_property: str = "Name",
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    payload = {
+        "parent": {"database_id": database_id},
+        "properties": {
+            title_property: {
+                "title": [{"text": {"content": title}}]
+            }
+        },
+        "children": [
+            {
+                "object": "block",
+                "type": "paragraph",
+                "paragraph": {
+                    "rich_text": [{"type": "text", "text": {"content": content[:1900]}}]
+                },
+            }
+        ],
+    }
+    if dry_run:
+        return {"ok": True, "mode": "dry_run", "payload": payload}
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Notion-Version": NOTION_VERSION,
+        "Content-Type": "application/json",
+    }
+    data = _http_json("POST", f"{NOTION_API_BASE}/pages", headers, payload)
+    return {"ok": True, "id": data.get("id"), "url": data.get("url")}
+
+
+def notion_query_database(
+    *,
+    token: str,
+    database_id: str,
+    page_size: int = 5,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    payload = {"page_size": page_size}
+    if dry_run:
+        return {"ok": True, "mode": "dry_run", "payload": payload}
+
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Notion-Version": NOTION_VERSION,
+        "Content-Type": "application/json",
+    }
+    data = _http_json("POST", f"{NOTION_API_BASE}/databases/{database_id}/query", headers, payload)
+    results = data.get("results", [])
+    slim = [{"id": x.get("id"), "url": x.get("url")} for x in results]
+    return {"ok": True, "count": len(slim), "items": slim}
+
+
+def r2_put_presigned(*, file_path: Path, presigned_url: str, dry_run: bool = False) -> dict[str, Any]:
+    if dry_run:
+        return {"ok": True, "mode": "dry_run", "file": str(file_path), "url_prefix": presigned_url[:40]}
+
+    proc = subprocess.run(
+        ["curl", "-sS", "-X", "PUT", "--upload-file", str(file_path), presigned_url],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    return {"ok": True, "response": proc.stdout.strip()}
+
+
+def r2_get_presigned(*, presigned_url: str, out_path: Path, dry_run: bool = False) -> dict[str, Any]:
+    if dry_run:
+        return {"ok": True, "mode": "dry_run", "out": str(out_path), "url_prefix": presigned_url[:40]}
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(["curl", "-sS", "-L", "-o", str(out_path), presigned_url], check=True)
+    return {"ok": True, "out": str(out_path)}