superlocalmemory 3.0.18 → 3.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.0.18",
+  "version": "3.0.20",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.0.18"
+version = "3.0.20"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}

package/src/superlocalmemory/cli/commands.py

@@ -27,6 +27,8 @@ def dispatch(args: Namespace) -> None:
         "remember": cmd_remember,
         "recall": cmd_recall,
         "forget": cmd_forget,
+        "delete": cmd_delete,
+        "update": cmd_update,
         "status": cmd_status,
         "health": cmd_health,
         "trace": cmd_trace,
@@ -199,6 +201,72 @@ def cmd_forget(args: Namespace) -> None:
         print("Cancelled.")
 
 
+def cmd_delete(args: Namespace) -> None:
+    """Delete a specific memory by exact fact ID."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    config = SLMConfig.load()
+    engine = MemoryEngine(config)
+    engine.initialize()
+
+    fact_id = args.fact_id.strip()
+    # Look up the memory first so user can confirm
+    rows = engine._db.execute(
+        "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+        (fact_id, engine.profile_id),
+    )
+    if not rows:
+        print(f"Memory not found: {fact_id}")
+        return
+
+    content_preview = dict(rows[0]).get("content", "")[:120]
+    print(f"Memory: {content_preview}")
+
+    if not getattr(args, "yes", False):
+        confirm = input("Delete this memory? [y/N] ").strip().lower()
+        if confirm not in ("y", "yes"):
+            print("Cancelled.")
+            return
+
+    engine._db.delete_fact(fact_id)
+    print(f"Deleted: {fact_id}")
+
+
+def cmd_update(args: Namespace) -> None:
+    """Update the content of a specific memory by exact fact ID."""
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.engine import MemoryEngine
+
+    config = SLMConfig.load()
+    engine = MemoryEngine(config)
+    engine.initialize()
+
+    fact_id = args.fact_id.strip()
+    new_content = args.content.strip()
+    if not new_content:
+        print("Error: content cannot be empty")
+        return
+
+    rows = engine._db.execute(
+        "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+        (fact_id, engine.profile_id),
+    )
+    if not rows:
+        print(f"Memory not found: {fact_id}")
+        return
+
+    old_content = dict(rows[0]).get("content", "")
+    print(f"Old: {old_content[:100]}")
+    print(f"New: {new_content[:100]}")
+
+    engine._db.execute(
+        "UPDATE atomic_facts SET content = ? WHERE fact_id = ?",
+        (new_content, fact_id),
+    )
+    print(f"Updated: {fact_id}")
+
+
 def cmd_status(_args: Namespace) -> None:
     """Show system status."""
     from superlocalmemory.core.config import SLMConfig

package/src/superlocalmemory/cli/main.py

@@ -119,10 +119,18 @@ def main() -> None:
     recall_p.add_argument("query", help="Search query")
     recall_p.add_argument("--limit", type=int, default=10, help="Max results (default 10)")
 
-    forget_p = sub.add_parser("forget", help="Delete memories matching a query")
+    forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
     forget_p.add_argument("query", help="Query to match for deletion")
 
-    list_p = sub.add_parser("list", help="List recent memories chronologically")
+    delete_p = sub.add_parser("delete", help="Delete a specific memory by ID (precise)")
+    delete_p.add_argument("fact_id", help="Exact fact ID to delete")
+    delete_p.add_argument("--yes", "-y", action="store_true", help="Skip confirmation")
+
+    update_p = sub.add_parser("update", help="Edit the content of a specific memory by ID")
+    update_p.add_argument("fact_id", help="Exact fact ID to update")
+    update_p.add_argument("content", help="New content for the memory")
+
+    list_p = sub.add_parser("list", help="List recent memories chronologically (shows IDs for delete/update)")
     list_p.add_argument(
         "--limit", "-n", type=int, default=20, help="Number of entries (default 20)",
     )

package/src/superlocalmemory/core/config.py

@@ -353,6 +353,7 @@ class SLMConfig:
                     provider=llm_provider or "ollama",
                     model=llm_model or "phi3:mini",
                     api_base=llm_api_base or "http://localhost:11434",
+                    api_key=llm_api_key or "",
                 ),
                 retrieval=RetrievalConfig(use_cross_encoder=True),
             )

package/src/superlocalmemory/core/recall_worker.py

@@ -78,6 +78,25 @@ def _handle_store(content: str, metadata: dict) -> dict:
     engine = _get_engine()
     session_id = metadata.pop("session_id", "")
     fact_ids = engine.store(content, session_id=session_id, metadata=metadata)
+
+    # Generate and persist summary immediately after store (Mode A heuristic, B/C LLM)
+    if fact_ids:
+        try:
+            from superlocalmemory.core.summarizer import Summarizer
+            summarizer = Summarizer(engine._config)
+            summary = summarizer.summarize_cluster([{"content": content}])
+            if summary:
+                # Get the memory_id from the first stored fact
+                rows = engine._db.execute(
+                    "SELECT memory_id FROM atomic_facts WHERE fact_id = ? LIMIT 1",
+                    (fact_ids[0],),
+                )
+                if rows:
+                    memory_id = dict(rows[0])["memory_id"]
+                    engine._db.update_memory_summary(memory_id, summary)
+        except Exception:
+            pass  # Summary is non-critical
+
     return {"ok": True, "fact_ids": fact_ids, "count": len(fact_ids)}
 
 
@@ -107,6 +126,49 @@ def _handle_get_memory_facts(memory_id: str) -> dict:
     }
 
 
+def _handle_delete_memory(fact_id: str, agent_id: str = "system") -> dict:
+    """Delete a specific atomic fact by ID with audit logging."""
+    engine = _get_engine()
+    pid = engine.profile_id
+    rows = engine._db.execute(
+        "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ? LIMIT 1",
+        (fact_id, pid),
+    )
+    if not rows:
+        return {"ok": False, "error": f"Memory {fact_id} not found"}
+    content_preview = dict(rows[0]).get("content", "")[:80]
+    engine._db.delete_fact(fact_id)
+    # Audit log
+    import logging as _logging
+    _logging.getLogger("superlocalmemory.audit").info(
+        "DELETE fact_id=%s by agent=%s content=%s", fact_id[:16], agent_id, content_preview,
+    )
+    return {"ok": True, "deleted": fact_id, "content_preview": content_preview}
+
+
+def _handle_update_memory(fact_id: str, content: str, agent_id: str = "system") -> dict:
+    """Update content of a specific atomic fact with audit logging."""
+    engine = _get_engine()
+    pid = engine.profile_id
+    rows = engine._db.execute(
+        "SELECT content FROM atomic_facts WHERE fact_id = ? AND profile_id = ? LIMIT 1",
+        (fact_id, pid),
+    )
+    if not rows:
+        return {"ok": False, "error": f"Memory {fact_id} not found"}
+    old_content = dict(rows[0]).get("content", "")[:80]
+    engine._db.execute(
+        "UPDATE atomic_facts SET content = ? WHERE fact_id = ?",
+        (content, fact_id),
+    )
+    import logging as _logging
+    _logging.getLogger("superlocalmemory.audit").info(
+        "UPDATE fact_id=%s by agent=%s old=%s new=%s",
+        fact_id[:16], agent_id, old_content, content[:80],
+    )
+    return {"ok": True, "fact_id": fact_id, "content": content}
+
+
 def _handle_summarize(texts: list[str], mode: str) -> dict:
     """Generate summary using heuristic (A) or LLM (B/C)."""
     from superlocalmemory.core.summarizer import Summarizer
@@ -167,6 +229,18 @@ def _worker_main() -> None:
             elif cmd == "store":
                 result = _handle_store(req.get("content", ""), req.get("metadata", {}))
                 _respond(result)
+            elif cmd == "delete_memory":
+                result = _handle_delete_memory(
+                    req.get("fact_id", ""), req.get("agent_id", "system"),
+                )
+                _respond(result)
+            elif cmd == "update_memory":
+                result = _handle_update_memory(
+                    req.get("fact_id", ""),
+                    req.get("content", ""),
+                    req.get("agent_id", "system"),
+                )
+                _respond(result)
             elif cmd == "get_memory_facts":
                 result = _handle_get_memory_facts(req.get("memory_id", ""))
                 _respond(result)

package/src/superlocalmemory/core/worker_pool.py

@@ -73,6 +73,14 @@ class WorkerPool:
             "metadata": metadata or {},
         })
 
+    def delete_memory(self, fact_id: str, agent_id: str = "system") -> dict:
+        """Delete a specific memory by fact_id. Logged for audit."""
+        return self._send({"cmd": "delete_memory", "fact_id": fact_id, "agent_id": agent_id})
+
+    def update_memory(self, fact_id: str, content: str, agent_id: str = "system") -> dict:
+        """Update content of a specific memory. Logged for audit."""
+        return self._send({"cmd": "update_memory", "fact_id": fact_id, "content": content, "agent_id": agent_id})
+
     def get_memory_facts(self, memory_id: str) -> dict:
         """Get original memory text + child atomic facts."""
         return self._send({"cmd": "get_memory_facts", "memory_id": memory_id})

package/src/superlocalmemory/mcp/tools_core.py

@@ -281,6 +281,67 @@ def register_core_tools(server, get_engine: Callable) -> None:
             logger.exception("correct_pattern failed")
             return {"success": False, "error": str(exc)}
 
+    @server.tool()
+    async def delete_memory(fact_id: str, agent_id: str = "mcp_client") -> dict:
+        """Delete a specific memory by exact fact ID.
+
+        Security note: This is a destructive operation. All deletions are
+        logged with the calling agent_id for audit trail. Use get_status or
+        list_recent to find fact_ids before deleting.
+
+        Args:
+            fact_id: Exact fact ID to delete (from recall or list_recent results).
+            agent_id: Identifier of the calling agent (logged for audit).
+        """
+        try:
+            from superlocalmemory.core.worker_pool import WorkerPool
+            pool = WorkerPool.shared()
+            result = pool._send({
+                "cmd": "delete_memory",
+                "fact_id": fact_id,
+                "agent_id": agent_id,
+            })
+            if result.get("ok"):
+                logger.info("Memory deleted: %s by agent: %s", fact_id[:16], agent_id)
+                return {"success": True, "deleted": fact_id, "agent_id": agent_id}
+            return {"success": False, "error": result.get("error", "Delete failed")}
+        except Exception as exc:
+            logger.exception("delete_memory failed")
+            return {"success": False, "error": str(exc)}
+
+    @server.tool()
+    async def update_memory(
+        fact_id: str, content: str, agent_id: str = "mcp_client",
+    ) -> dict:
+        """Update the content of a specific memory by exact fact ID.
+
+        Security note: All updates are logged with the calling agent_id.
+        The fact_id must belong to the active profile.
+
+        Args:
+            fact_id: Exact fact ID to update.
+            content: New content for the memory (cannot be empty).
+            agent_id: Identifier of the calling agent (logged for audit).
+        """
+        try:
+            if not content or not content.strip():
+                return {"success": False, "error": "content cannot be empty"}
+            from superlocalmemory.core.worker_pool import WorkerPool
+            pool = WorkerPool.shared()
+            result = pool._send({
+                "cmd": "update_memory",
+                "fact_id": fact_id,
+                "content": content.strip(),
+                "agent_id": agent_id,
+            })
+            if result.get("ok"):
+                logger.info("Memory updated: %s by agent: %s", fact_id[:16], agent_id)
+                return {"success": True, "fact_id": fact_id, "content": content.strip()}
+            return {"success": False, "error": result.get("error", "Update failed")}
+        except Exception as exc:
+            logger.exception("update_memory failed")
+            return {"success": False, "error": str(exc)}
+
     @server.tool()
     async def get_attribution() -> dict:
         """Get system attribution: author, version, license, and provenance metadata."""

package/src/superlocalmemory/server/routes/memories.py

@@ -455,3 +455,61 @@ async def get_memory_facts(request: Request, memory_id: str):
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+
+@router.delete("/api/memories/{fact_id}")
+async def delete_memory(request: Request, fact_id: str):
+    """Delete a specific memory (atomic fact) by ID."""
+    try:
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        active_profile = get_active_profile()
+        # Verify it exists and belongs to this profile
+        cursor.execute(
+            "SELECT fact_id FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+            (fact_id, active_profile),
+        )
+        if not cursor.fetchone():
+            conn.close()
+            raise HTTPException(status_code=404, detail="Memory not found")
+        cursor.execute("DELETE FROM atomic_facts WHERE fact_id = ?", (fact_id,))
+        conn.commit()
+        conn.close()
+        return {"success": True, "deleted": fact_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Delete error: {str(e)}")
+
+
+@router.patch("/api/memories/{fact_id}")
+async def edit_memory(request: Request, fact_id: str):
+    """Edit the content of a specific memory (atomic fact)."""
+    try:
+        body = await request.json()
+        new_content = (body.get("content") or "").strip()
+        if not new_content:
+            raise HTTPException(status_code=400, detail="content is required")
+        conn = get_db_connection()
+        conn.row_factory = dict_factory
+        cursor = conn.cursor()
+        active_profile = get_active_profile()
+        cursor.execute(
+            "SELECT fact_id FROM atomic_facts WHERE fact_id = ? AND profile_id = ?",
+            (fact_id, active_profile),
+        )
+        if not cursor.fetchone():
+            conn.close()
+            raise HTTPException(status_code=404, detail="Memory not found")
+        cursor.execute(
+            "UPDATE atomic_facts SET content = ? WHERE fact_id = ?",
+            (new_content, fact_id),
+        )
+        conn.commit()
+        conn.close()
+        return {"success": True, "fact_id": fact_id, "content": new_content}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Edit error: {str(e)}")

package/src/superlocalmemory/storage/database.py

@@ -128,6 +128,32 @@ class DatabaseManager:
         )
         return record.memory_id
 
+    def update_memory_summary(self, memory_id: str, summary: str) -> None:
+        """Store a generated summary for a memory record."""
+        try:
+            self.execute(
+                "UPDATE memories SET metadata_json = json_set("
+                "  COALESCE(metadata_json, '{}'), '$.summary', ?"
+                ") WHERE memory_id = ?",
+                (summary, memory_id),
+            )
+        except Exception:
+            pass  # Non-critical — summary is enhancement only
+
+    def get_memory_summary(self, memory_id: str) -> str:
+        """Retrieve stored summary for a memory, or empty string."""
+        try:
+            rows = self.execute(
+                "SELECT json_extract(metadata_json, '$.summary') as s "
+                "FROM memories WHERE memory_id = ?",
+                (memory_id,),
+            )
+            if rows:
+                return dict(rows[0]).get("s") or ""
+        except Exception:
+            pass
+        return ""
+
     def store_fact(self, fact: AtomicFact) -> str:
         """Persist an atomic fact. Returns fact_id."""
         self.execute(

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.0.18
+Version: 3.0.20
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: MIT

package/ui/js/modal.js

@@ -176,6 +176,63 @@ function openMemoryDetail(mem, source) {
             actionsDiv.appendChild(filterBtn);
         }
 
+        // Edit button — always available
+        var editBtn = document.createElement('button');
+        editBtn.className = 'btn btn-outline-warning btn-sm';
+        editBtn.innerHTML = '<i class="bi bi-pencil"></i> Edit';
+        editBtn.onclick = function() {
+            var currentText = contentDiv.textContent;
+            var textarea = document.createElement('textarea');
+            textarea.className = 'form-control mb-2';
+            textarea.rows = 4;
+            textarea.value = currentText;
+            contentDiv.textContent = '';
+            contentDiv.appendChild(textarea);
+            var saveBtn = document.createElement('button');
+            saveBtn.className = 'btn btn-sm btn-success me-1';
+            saveBtn.textContent = 'Save';
+            saveBtn.onclick = function() {
+                var newContent = textarea.value.trim();
+                if (!newContent) return;
+                fetch('/api/memories/' + encodeURIComponent(mem.id), {
+                    method: 'PATCH',
+                    headers: {'Content-Type': 'application/json'},
+                    body: JSON.stringify({content: newContent})
+                }).then(function(r) { return r.json(); }).then(function(d) {
+                    if (d.success) {
+                        contentDiv.textContent = newContent;
+                        mem.content = newContent;
+                        if (typeof showToast === 'function') showToast('Memory updated');
+                    }
+                });
+            };
+            var cancelBtn = document.createElement('button');
+            cancelBtn.className = 'btn btn-sm btn-secondary';
+            cancelBtn.textContent = 'Cancel';
+            cancelBtn.onclick = function() { contentDiv.textContent = currentText; };
+            contentDiv.appendChild(saveBtn);
+            contentDiv.appendChild(cancelBtn);
+        };
+        actionsDiv.appendChild(editBtn);
+
+        // Delete button — always available
+        var deleteBtn = document.createElement('button');
+        deleteBtn.className = 'btn btn-outline-danger btn-sm';
+        deleteBtn.innerHTML = '<i class="bi bi-trash"></i> Delete';
+        deleteBtn.onclick = function() {
+            if (!confirm('Delete this memory? This cannot be undone.')) return;
+            fetch('/api/memories/' + encodeURIComponent(mem.id), {method: 'DELETE'})
+                .then(function(r) { return r.json(); })
+                .then(function(d) {
+                    if (d.success) {
+                        modal.hide();
+                        if (typeof showToast === 'function') showToast('Memory deleted');
+                        if (typeof loadMemories === 'function') setTimeout(loadMemories, 300);
+                    }
+                });
+        };
+        actionsDiv.appendChild(deleteBtn);
+
         body.appendChild(actionsDiv);
     }