yourmemory 1.4.77__tar.gz → 1.4.78__tar.gz

{yourmemory-1.4.77 → yourmemory-1.4.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yourmemory
-Version: 1.4.77
+Version: 1.4.78
 Summary: Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native
 Author: Sachit Misra
 Author-email: mishrasachit1@gmail.com

{yourmemory-1.4.77 → yourmemory-1.4.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yourmemory"
-version = "1.4.77"
+version = "1.4.78"
 description = "Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native"
 readme = "README.md"
 requires-python = ">=3.11"

{yourmemory-1.4.77 → yourmemory-1.4.78}/src/app.py

@@ -13,7 +13,7 @@ from collections import defaultdict, deque
 from threading import Lock
 from fastapi import Request
 from fastapi.responses import JSONResponse
-from src.routes import memories, retrieve, agents, ui, graph_viz, proxy, audit, dsar, compact
+from src.routes import memories, retrieve, agents, ui, graph_viz, proxy, audit, dsar, compact, pools
 from src.jobs.decay_job import run as run_decay
 from src.services.audit import prune_expired as prune_audit
 from src.db.migrate import migrate
@@ -52,6 +52,7 @@ app.include_router(proxy.router)
 app.include_router(audit.router)
 app.include_router(dsar.router)
 app.include_router(compact.router)
+app.include_router(pools.router)
 
 
 # ── Rate limiting (abuse prevention) ────────────────────────────────────────────

{yourmemory-1.4.77 → yourmemory-1.4.78}/src/db/migrate.py

@@ -220,6 +220,76 @@ def _create_archive_table(conn, backend: str) -> None:
         """)
 
 
+def _create_pool_tables(conn, backend: str) -> None:
+    """Shared memory pools (team / institutional memory). A pool's memories live in the
+    `memories` table under a namespaced user_id ('pool:<id>'), so they reuse all existing
+    machinery (embedding, dedup, recall, decay, compaction, audit). These two tables hold
+    the pool registry and role-based membership. Idempotent across backends."""
+    if backend == "postgres":
+        cur = conn.cursor()
+        cur.execute("""
+            CREATE TABLE IF NOT EXISTS pools (
+                pool_id    TEXT PRIMARY KEY,
+                name       TEXT,
+                owner      TEXT,
+                created_at TIMESTAMPTZ DEFAULT NOW()
+            );
+            CREATE TABLE IF NOT EXISTS pool_members (
+                pool_id   TEXT NOT NULL,
+                member_id TEXT NOT NULL,
+                role      TEXT NOT NULL DEFAULT 'reader',
+                can_read  BOOLEAN NOT NULL DEFAULT TRUE,
+                can_write BOOLEAN NOT NULL DEFAULT FALSE,
+                added_at  TIMESTAMPTZ DEFAULT NOW(),
+                PRIMARY KEY (pool_id, member_id)
+            );
+            CREATE INDEX IF NOT EXISTS idx_pool_member ON pool_members(member_id);
+        """)
+        conn.commit()
+        cur.close()
+    elif backend == "duckdb":
+        try:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS pools (
+                    pool_id    VARCHAR PRIMARY KEY,
+                    name       VARCHAR,
+                    owner      VARCHAR,
+                    created_at TIMESTAMP DEFAULT now()
+                )""")
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS pool_members (
+                    pool_id   VARCHAR NOT NULL,
+                    member_id VARCHAR NOT NULL,
+                    role      VARCHAR NOT NULL DEFAULT 'reader',
+                    can_read  BOOLEAN NOT NULL DEFAULT TRUE,
+                    can_write BOOLEAN NOT NULL DEFAULT FALSE,
+                    added_at  TIMESTAMP DEFAULT now(),
+                    PRIMARY KEY (pool_id, member_id)
+                )""")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_pool_member ON pool_members(member_id)")
+        except Exception as exc:
+            print(f"pool tables (duckdb) skipped: {exc}", file=sys.stderr)
+    else:  # sqlite
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS pools (
+                pool_id    TEXT PRIMARY KEY,
+                name       TEXT,
+                owner      TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+            CREATE TABLE IF NOT EXISTS pool_members (
+                pool_id   TEXT NOT NULL,
+                member_id TEXT NOT NULL,
+                role      TEXT NOT NULL DEFAULT 'reader',
+                can_read  INTEGER NOT NULL DEFAULT 1,
+                can_write INTEGER NOT NULL DEFAULT 0,
+                added_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                PRIMARY KEY (pool_id, member_id)
+            );
+            CREATE INDEX IF NOT EXISTS idx_pool_member ON pool_members(member_id);
+        """)
+
+
 def migrate():
     backend = get_backend()
 
@@ -262,6 +332,9 @@ def migrate():
     # ── Archive of originals compressed into summaries (memory compaction) ──
     _create_archive_table(conn, backend)
 
+    # ── Shared memory pools (team / institutional memory) ──
+    _create_pool_tables(conn, backend)
+
     # ── Post-schema FTS setup ─────────────────────────────────────────────
     if backend == "sqlite":
         # Backfill any rows that existed before the FTS table was created.

yourmemory-1.4.78/src/routes/pools.py

@@ -0,0 +1,236 @@
+"""
+Shared memory pools — team / institutional memory.
+
+A pool is a shared namespace many agents contribute to and everyone with access can
+query. Individual agents still write their own personal memories; the pool is the
+team-level layer on top. Pool memories are stored in the `memories` table under a
+namespaced user_id (`pool:<id>`), so they reuse embedding, dedup, recall, decay,
+compaction, and audit for free.
+
+  POST /pools                         create a pool
+  GET  /pools                         list pools
+  POST /pools/{id}/members            add a member with a role (reader/contributor/admin)
+  GET  /pools/{id}/members            list members
+  POST /pools/{id}/memories           write a memory into the pool (writer role required)
+  GET  /pools/{id}/memories           list pool memories (reader role required)
+  POST /pools/{id}/retrieve           semantic search within the pool
+
+Role → permissions:  reader = read · contributor = read+write · admin = read+write+manage.
+
+> NOTE: in the default local deployment the caller identity (`memberId`) is supplied by
+> the client and access checks are advisory — real enforcement arrives with hosted auth.
+> The pool model, membership, and union recall are the durable substrate that hosted
+> RBAC will enforce.
+"""
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+from typing import Optional, List
+
+from src.db.connection import get_backend, get_conn, duckdb_rows
+from src.services.audit import log_event
+
+router = APIRouter()
+
+POOL_NS = "pool:"          # memories namespace prefix
+_ROLE_PERMS = {
+    "reader":      (True,  False),
+    "contributor": (True,  True),
+    "admin":       (True,  True),
+}
+
+
+def _ns(pool_id: str) -> str:
+    return f"{POOL_NS}{pool_id.strip().lower()}"
+
+
+def _ph(backend: str) -> str:
+    return "%s" if backend == "postgres" else "?"
+
+
+def _member(conn, backend: str, pool_id: str, member_id: str) -> Optional[dict]:
+    p = _ph(backend)
+    sql = f"SELECT role, can_read, can_write FROM pool_members WHERE pool_id = {p} AND member_id = {p}"
+    args = (pool_id, member_id)
+    if backend == "duckdb":
+        rows = duckdb_rows(conn.execute(sql, list(args)))
+        return rows[0] if rows else None
+    cur = conn.cursor(); cur.execute(sql, args)
+    row = cur.fetchone(); cur.close()
+    if not row:
+        return None
+    return {"role": row[0], "can_read": bool(row[1]), "can_write": bool(row[2])}
+
+
+def _require(pool_id: str, member_id: str, need: str):
+    """Advisory access check. need = 'read' | 'write'. Returns the membership dict."""
+    if not member_id:
+        raise HTTPException(403, "memberId required to access a pool.")
+    backend = get_backend(); conn = get_conn()
+    try:
+        m = _member(conn, backend, pool_id.strip().lower(), member_id.strip().lower())
+    finally:
+        conn.close()
+    if not m:
+        raise HTTPException(403, f"'{member_id}' is not a member of pool '{pool_id}'.")
+    if need == "read" and not m["can_read"]:
+        raise HTTPException(403, "Member lacks read access to this pool.")
+    if need == "write" and not m["can_write"]:
+        raise HTTPException(403, "Member lacks write access to this pool.")
+    return m
+
+
+# ── Create / list pools ─────────────────────────────────────────────────────────
+
+class CreatePoolRequest(BaseModel):
+    pool_id: str
+    name:    Optional[str] = ""
+    owner:   str
+
+
+@router.post("/pools")
+def create_pool(req: CreatePoolRequest):
+    pool_id = req.pool_id.strip().lower()
+    owner   = req.owner.strip().lower()
+    if not pool_id or not owner:
+        raise HTTPException(422, "pool_id and owner are required.")
+    backend = get_backend(); conn = get_conn(); p = _ph(backend)
+    try:
+        # Create the pool and make the owner an admin member.
+        if backend == "duckdb":
+            conn.execute(f"INSERT INTO pools (pool_id, name, owner) VALUES (?,?,?) ON CONFLICT (pool_id) DO NOTHING",
+                         [pool_id, req.name, owner])
+            conn.execute("INSERT INTO pool_members (pool_id, member_id, role, can_read, can_write) "
+                         "VALUES (?,?,?,?,?) ON CONFLICT (pool_id, member_id) DO UPDATE SET role=excluded.role",
+                         [pool_id, owner, "admin", True, True])
+        else:
+            cur = conn.cursor()
+            cur.execute(f"INSERT INTO pools (pool_id, name, owner) VALUES ({p},{p},{p}) ON CONFLICT (pool_id) DO NOTHING",
+                        (pool_id, req.name, owner))
+            cur.execute(f"INSERT INTO pool_members (pool_id, member_id, role, can_read, can_write) "
+                        f"VALUES ({p},{p},{p},{p},{p}) ON CONFLICT (pool_id, member_id) DO UPDATE SET role=excluded.role",
+                        (pool_id, owner, "admin", True, True))
+            conn.commit(); cur.close()
+    finally:
+        conn.close()
+    log_event("write", "pool_create", owner, detail={"pool_id": pool_id})
+    return {"pool_id": pool_id, "name": req.name, "owner": owner, "role": "admin"}
+
+
+@router.get("/pools")
+def list_pools(memberId: Optional[str] = Query(None, description="Filter to pools this member belongs to")):
+    backend = get_backend(); conn = get_conn(); p = _ph(backend)
+    try:
+        if memberId:
+            mid = memberId.strip().lower()
+            sql = (f"SELECT p.pool_id, p.name, p.owner, m.role FROM pools p "
+                   f"JOIN pool_members m ON p.pool_id = m.pool_id WHERE m.member_id = {p} ORDER BY p.pool_id")
+            args = (mid,)
+        else:
+            sql = "SELECT pool_id, name, owner, '' AS role FROM pools ORDER BY pool_id"
+            args = ()
+        if backend == "duckdb":
+            rows = duckdb_rows(conn.execute(sql, list(args)))
+        else:
+            cur = conn.cursor(); cur.execute(sql, args)
+            cols = [d[0] for d in cur.description]
+            rows = [dict(zip(cols, r)) for r in cur.fetchall()]; cur.close()
+    finally:
+        conn.close()
+    return {"count": len(rows), "pools": rows}
+
+
+# ── Membership ──────────────────────────────────────────────────────────────────
+
+class AddMemberRequest(BaseModel):
+    member_id: str
+    role:      str = "reader"   # reader | contributor | admin
+
+
+@router.post("/pools/{pool_id}/members")
+def add_member(pool_id: str, req: AddMemberRequest):
+    pool_id = pool_id.strip().lower()
+    member_id = req.member_id.strip().lower()
+    role = req.role.strip().lower()
+    if role not in _ROLE_PERMS:
+        raise HTTPException(422, f"role must be one of {list(_ROLE_PERMS)}")
+    can_read, can_write = _ROLE_PERMS[role]
+    backend = get_backend(); conn = get_conn(); p = _ph(backend)
+    try:
+        if backend == "duckdb":
+            conn.execute("INSERT INTO pool_members (pool_id, member_id, role, can_read, can_write) "
+                         "VALUES (?,?,?,?,?) ON CONFLICT (pool_id, member_id) DO UPDATE SET "
+                         "role=excluded.role, can_read=excluded.can_read, can_write=excluded.can_write",
+                         [pool_id, member_id, role, can_read, can_write])
+        else:
+            cur = conn.cursor()
+            cur.execute(f"INSERT INTO pool_members (pool_id, member_id, role, can_read, can_write) "
+                        f"VALUES ({p},{p},{p},{p},{p}) ON CONFLICT (pool_id, member_id) DO UPDATE SET "
+                        f"role=excluded.role, can_read=excluded.can_read, can_write=excluded.can_write",
+                        (pool_id, member_id, role, can_read, can_write))
+            conn.commit(); cur.close()
+    finally:
+        conn.close()
+    return {"pool_id": pool_id, "member_id": member_id, "role": role,
+            "can_read": can_read, "can_write": can_write}
+
+
+@router.get("/pools/{pool_id}/members")
+def list_members(pool_id: str):
+    pool_id = pool_id.strip().lower()
+    backend = get_backend(); conn = get_conn(); p = _ph(backend)
+    sql = f"SELECT member_id, role, can_read, can_write FROM pool_members WHERE pool_id = {p} ORDER BY member_id"
+    try:
+        if backend == "duckdb":
+            rows = duckdb_rows(conn.execute(sql, [pool_id]))
+        else:
+            cur = conn.cursor(); cur.execute(sql, (pool_id,))
+            cols = [d[0] for d in cur.description]
+            rows = [dict(zip(cols, r)) for r in cur.fetchall()]; cur.close()
+    finally:
+        conn.close()
+    return {"pool_id": pool_id, "count": len(rows), "members": rows}
+
+
+# ── Pool memories: write / list / retrieve (reuse the memory engine) ────────────
+
+class PoolMemoryRequest(BaseModel):
+    memberId:   str
+    content:    str
+    importance: float = 0.5
+    category:   Optional[str] = None
+
+
+@router.post("/pools/{pool_id}/memories")
+def write_pool_memory(pool_id: str, req: PoolMemoryRequest):
+    _require(pool_id, req.memberId, "write")
+    from src.routes.memories import add_memory, MemoryRequest
+    result = add_memory(MemoryRequest(
+        userId=_ns(pool_id), content=req.content, importance=req.importance))
+    log_event("write", "pool_store", req.memberId.strip().lower(),
+              detail={"pool_id": pool_id.strip().lower(), "id": result.get("id")})
+    return {"pool_id": pool_id.strip().lower(), **result}
+
+
+@router.get("/pools/{pool_id}/memories")
+def list_pool_memories(pool_id: str, memberId: str = Query(...), limit: int = Query(50, ge=1, le=500)):
+    _require(pool_id, memberId, "read")
+    from src.routes.memories import list_memories
+    return list_memories(userId=_ns(pool_id), limit=limit)
+
+
+class PoolRetrieveRequest(BaseModel):
+    memberId: str
+    query:    str
+    topK:     int = 6
+
+
+@router.post("/pools/{pool_id}/retrieve")
+def retrieve_pool(pool_id: str, req: PoolRetrieveRequest):
+    _require(pool_id, req.memberId, "read")
+    from src.services.retrieve import retrieve as _retrieve
+    result = _retrieve(_ns(pool_id), req.query, req.topK)
+    log_event("read", "pool_retrieve", req.memberId.strip().lower(),
+              detail={"pool_id": pool_id.strip().lower(),
+                      "count": len(result.get("memories", []))})
+    return result

{yourmemory-1.4.77 → yourmemory-1.4.78}/src/routes/retrieve.py

@@ -21,20 +21,45 @@ class RetrieveRequest(BaseModel):
     scope:          Optional[List[str]]  = None        # hard filter by context_paths scope
     currentPath:    Optional[str]        = None        # spatial boost: current file/dir path
     noGraph:        bool                 = False       # ablation: skip graph expansion
+    pools:          Optional[List[str]]  = None        # also search these shared pools (if a member)
 
 
 @router.post("/retrieve")
 def retrieve_memories(req: RetrieveRequest):
     user_id = req.userId.strip().lower()
 
-    # ── Recall throttling ──────────────────────────────────────────────────
-    cached = recall_cached(user_id, req.query)
-    if cached is not None:
-        return cached
+    # ── Recall throttling (bypassed when pools are requested — results differ) ──
+    if not req.pools:
+        cached = recall_cached(user_id, req.query)
+        if cached is not None:
+            return cached
 
     result = retrieve(user_id, req.query, req.topK, current_path=req.currentPath, no_graph=req.noGraph,
                       score_threshold=req.scoreThreshold, scope=req.scope, expand_k=req.expandK)
 
+    # ── Union with shared pools the caller may read (institutional memory) ──
+    if req.pools:
+        try:
+            from src.routes.pools import _ns, _member
+            from src.db.connection import get_backend as _gb, get_conn as _gc
+            backend = _gb(); conn = _gc()
+            try:
+                readable = [p.strip().lower() for p in req.pools
+                            if (lambda m: m and m["can_read"])(_member(conn, backend, p.strip().lower(), user_id))]
+            finally:
+                conn.close()
+            merged = list(result.get("memories", []))
+            for pid in readable:
+                pr = retrieve(_ns(pid), req.query, req.topK)
+                for mm in pr.get("memories", []):
+                    mm["pool"] = pid
+                    merged.append(mm)
+            merged.sort(key=lambda m: m.get("score", 0), reverse=True)
+            result["memories"] = merged[:req.topK]
+            result["memoriesFound"] = len(result["memories"])
+        except Exception:
+            pass
+
     # ── Session wrap-up tracking ───────────────────────────────────────────
     session_track(user_id, [m["id"] for m in result.get("memories", [])])
 

{yourmemory-1.4.77 → yourmemory-1.4.78}/yourmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yourmemory
-Version: 1.4.77
+Version: 1.4.78
 Summary: Persistent memory for Claude — Ebbinghaus forgetting curve, semantic deduplication, MCP-native
 Author: Sachit Misra
 Author-email: mishrasachit1@gmail.com

{yourmemory-1.4.77 → yourmemory-1.4.78}/yourmemory.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ src/routes/compact.py
 src/routes/dsar.py
 src/routes/graph_viz.py
 src/routes/memories.py
+src/routes/pools.py
 src/routes/proxy.py
 src/routes/retrieve.py
 src/routes/ui.py