get-claudia 1.34.1 → 1.34.2

package/memory-daemon/claudia_memory/__main__.py

@@ -177,6 +177,11 @@ def main():
         action="store_true",
         help="Launch the Brain Monitor terminal dashboard (requires: pip install claudia-memory[tui])",
     )
+    parser.add_argument(
+        "--backfill-embeddings",
+        action="store_true",
+        help="Generate embeddings for all memories that don't have them yet, then exit",
+    )
 
     args = parser.parse_args()
 
@@ -220,6 +225,52 @@ def main():
         run_brain_monitor(db_path=get_config().db_path)
         return
 
+    if args.backfill_embeddings:
+        # One-shot: generate embeddings for memories missing them
+        setup_logging(debug=args.debug)
+        from .embeddings import get_embedding_service
+
+        db = get_db()
+        db.initialize()
+
+        # Find memories not in the memory_embeddings table
+        missing = db.execute(
+            "SELECT m.id, m.content FROM memories m "
+            "LEFT JOIN memory_embeddings me ON m.id = me.memory_id "
+            "WHERE me.memory_id IS NULL",
+            fetch=True,
+        )
+
+        if not missing:
+            print("All memories already have embeddings. Nothing to do.")
+            return
+
+        print(f"Found {len(missing)} memories without embeddings. Generating...")
+        svc = get_embedding_service()
+        if not svc.is_available_sync():
+            print("Error: Ollama is not available. Start Ollama and try again.")
+            sys.exit(1)
+
+        success = 0
+        failed = 0
+        for i, row in enumerate(missing, 1):
+            embedding = svc.embed_sync(row["content"])
+            if embedding:
+                import struct
+                blob = struct.pack(f"{len(embedding)}f", *embedding)
+                db.execute(
+                    "INSERT OR REPLACE INTO memory_embeddings (memory_id, embedding) VALUES (?, ?)",
+                    (row["id"], blob),
+                )
+                success += 1
+            else:
+                failed += 1
+            if i % 10 == 0 or i == len(missing):
+                print(f"  Progress: {i}/{len(missing)} (success={success}, failed={failed})")
+
+        print(f"Backfill complete: {success} embedded, {failed} failed, {len(missing)} total.")
+        return
+
     # Run the daemon
     run_daemon(mcp_mode=not args.standalone, debug=args.debug, project_id=project_id)
 

package/memory-daemon/claudia_memory/database.py

@@ -55,9 +55,15 @@ class Database:
             loaded = False
 
             # Method 1: Try sqlite_vec Python package (recommended, works everywhere)
+            # Python 3.14+ requires explicit enable_load_extension() before any
+            # extension loading, even via the sqlite_vec helper package.
             try:
                 import sqlite_vec
+                if hasattr(conn, "enable_load_extension"):
+                    conn.enable_load_extension(True)
                 sqlite_vec.load(conn)
+                if hasattr(conn, "enable_load_extension"):
+                    conn.enable_load_extension(False)
                 loaded = True
                 logger.debug("Loaded sqlite-vec via Python package")
             except ImportError:

package/memory-daemon/tests/test_database.py

@@ -165,3 +165,39 @@ def test_migration_integrity_detects_missing_verification_status():
         assert effective_version <= 4, f"Should return version <= 4 to re-run migration 5, got {effective_version}"
 
         database.close()
+
+
+def test_sqlite_vec_loads_with_enable_extension():
+    """sqlite-vec loads correctly with enable_load_extension (Python 3.14+ compat).
+
+    Verifies that the Database class can load sqlite-vec and create vec0
+    virtual tables. Skips if sqlite_vec isn't installed or if the Python
+    build omits extension loading support (SQLITE_OMIT_LOAD_EXTENSION).
+    """
+    try:
+        import sqlite_vec  # noqa: F401
+    except ImportError:
+        pytest.skip("sqlite_vec package not installed")
+
+    # Check if this Python build supports extension loading at all
+    import sqlite3 as _sqlite3
+    _test_conn = _sqlite3.connect(":memory:")
+    if not hasattr(_test_conn, "enable_load_extension"):
+        _test_conn.close()
+        pytest.skip("Python built without SQLITE_LOAD_EXTENSION support")
+    _test_conn.close()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test_vec.db"
+        db = Database(db_path)
+        db.initialize()
+
+        # If sqlite-vec loaded, we should be able to query a vec0 table
+        # memory_embeddings is created in schema.sql as a vec0 virtual table
+        result = db.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='memory_embeddings'",
+            fetch=True,
+        )
+        assert len(result) > 0, "memory_embeddings vec0 table should exist when sqlite-vec is loaded"
+
+        db.close()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "get-claudia",
-  "version": "1.34.1",
+  "version": "1.34.2",
   "description": "An AI assistant who learns how you work.",
   "keywords": [
     "claudia",