superlocalmemory 3.0.2 → 3.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.0.2",
+  "version": "3.0.5",
   "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/scripts/postinstall.js

@@ -7,6 +7,7 @@
  * Repository: https://github.com/qualixar/superlocalmemory
  */
 
+const { spawnSync } = require('child_process');
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
@@ -17,11 +18,8 @@ console.log('  by Varun Pratap Bhardwaj / Qualixar');
 console.log('  https://github.com/qualixar/superlocalmemory');
 console.log('════════════════════════════════════════════════════════════\n');
 
-// V3 data directory
+// --- Step 1: Create data directory ---
 const SLM_HOME = path.join(os.homedir(), '.superlocalmemory');
-const V2_HOME = path.join(os.homedir(), '.claude-memory');
-
-// Ensure V3 data directory exists
 if (!fs.existsSync(SLM_HOME)) {
     fs.mkdirSync(SLM_HOME, { recursive: true });
     console.log('✓ Created data directory: ' + SLM_HOME);
@@ -29,7 +27,80 @@ if (!fs.existsSync(SLM_HOME)) {
     console.log('✓ Data directory exists: ' + SLM_HOME);
 }
 
-// Detect V2 installation
+// --- Step 2: Find Python 3 ---
+function findPython() {
+    const candidates = ['python3', 'python', '/opt/homebrew/bin/python3', '/usr/local/bin/python3', '/usr/bin/python3'];
+    if (os.platform() === 'win32') candidates.push('py -3');
+    for (const cmd of candidates) {
+        try {
+            const parts = cmd.split(' ');
+            const r = spawnSync(parts[0], [...parts.slice(1), '--version'], { stdio: 'pipe', timeout: 5000 });
+            if (r.status === 0 && (r.stdout || '').toString().includes('3.')) return cmd;
+        } catch (e) { /* next */ }
+    }
+    return null;
+}
+
+const python = findPython();
+if (!python) {
+    console.log('⚠ Python 3.11+ not found. Install from https://python.org/downloads/');
+    console.log('  After installing Python, run: slm setup');
+    process.exit(0); // Don't fail npm install
+}
+console.log('✓ Found Python: ' + python);
+
+// --- Step 3: Install Python dependencies ---
+console.log('\nInstalling Python dependencies...');
+const PKG_ROOT = path.join(__dirname, '..');
+const requirementsFile = path.join(PKG_ROOT, 'src', 'superlocalmemory', 'requirements-install.txt');
+
+// Create a minimal requirements file for core operation
+const coreDeps = [
+    'numpy>=1.26.0',
+    'scipy>=1.12.0',
+    'networkx>=3.0',
+    'httpx>=0.24.0',
+    'python-dateutil>=2.9.0',
+    'rank-bm25>=0.2.2',
+    'vaderSentiment>=3.3.2',
+].join('\n');
+
+// Write temp requirements file
+const tmpReq = path.join(SLM_HOME, '.install-requirements.txt');
+fs.writeFileSync(tmpReq, coreDeps);
+
+const pythonParts = python.split(' ');
+const pipResult = spawnSync(pythonParts[0], [
+    ...pythonParts.slice(1), '-m', 'pip', 'install', '--quiet', '--disable-pip-version-check',
+    '-r', tmpReq,
+], { stdio: 'inherit', timeout: 120000 });
+
+if (pipResult.status === 0) {
+    console.log('✓ Core Python dependencies installed');
+} else {
+    console.log('⚠ Some Python dependencies failed to install.');
+    console.log('  Run manually: ' + python + ' -m pip install numpy scipy networkx httpx python-dateutil rank-bm25 vaderSentiment');
+}
+
+// Clean up temp file
+try { fs.unlinkSync(tmpReq); } catch (e) { /* ok */ }
+
+// --- Step 4: Optional search dependencies (sentence-transformers) ---
+console.log('\nChecking optional search dependencies...');
+const stCheck = spawnSync(pythonParts[0], [
+    ...pythonParts.slice(1), '-c', 'import sentence_transformers; print("ok")',
+], { stdio: 'pipe', timeout: 10000 });
+
+if (stCheck.status === 0) {
+    console.log('✓ sentence-transformers already installed (semantic search enabled)');
+} else {
+    console.log('ℹ sentence-transformers not installed (BM25-only search mode)');
+    console.log('  For semantic search, run: ' + python + ' -m pip install sentence-transformers');
+    console.log('  This downloads ~1.5GB of ML models on first use.');
+}
+
+// --- Step 5: Detect V2 installation ---
+const V2_HOME = path.join(os.homedir(), '.claude-memory');
 if (fs.existsSync(V2_HOME) && fs.existsSync(path.join(V2_HOME, 'memory.db'))) {
     console.log('');
     console.log('╔══════════════════════════════════════════════════════════╗');
@@ -42,11 +113,9 @@ if (fs.existsSync(V2_HOME) && fs.existsSync(path.join(V2_HOME, 'memory.db'))) {
     console.log('  To migrate V2 data to V3, run:');
     console.log('    slm migrate');
     console.log('');
-    console.log('  Read the migration guide:');
-    console.log('    https://github.com/qualixar/superlocalmemory/wiki/Migration-from-V2');
-    console.log('');
 }
 
+// --- Done ---
 console.log('════════════════════════════════════════════════════════════');
 console.log('  ✓ SuperLocalMemory V3 installed successfully!');
 console.log('');

package/src/superlocalmemory/core/embeddings.py

@@ -56,6 +56,14 @@ class EmbeddingService:
         self._model: object | None = None
         self._lock = threading.Lock()
         self._loaded = False
+        self._available = True  # Set False if model can't load
+
+    @property
+    def is_available(self) -> bool:
+        """Check if embedding service has a usable model."""
+        if not self._loaded:
+            self._ensure_loaded()
+        return self._available and self._model is not None
 
     # ------------------------------------------------------------------
     # Public API
@@ -78,6 +86,9 @@ class EmbeddingService:
         """
         if not text or not text.strip():
             raise ValueError("Cannot embed empty text")
+        self._ensure_loaded()
+        if self._model is None:
+            return None
         vec = self._encode_single(text)
         self._validate_dimension(vec)
         return vec.tolist()
@@ -98,6 +109,9 @@ class EmbeddingService:
             if not t or not t.strip():
                 raise ValueError(f"Text at index {i} is empty")
 
+        self._ensure_loaded()
+        if self._model is None:
+            return [None] * len(texts)
         vectors = self._encode_batch(texts)
         for vec in vectors:
             self._validate_dimension(vec)
@@ -175,10 +189,14 @@ class EmbeddingService:
         try:
             from sentence_transformers import SentenceTransformer
         except ImportError:
-            raise ImportError(
-                "sentence-transformers required: "
-                "pip install sentence-transformers"
+            logger.warning(
+                "sentence-transformers not installed. Embeddings disabled. "
+                "Install with: pip install sentence-transformers"
             )
+            self._model = None
+            self._loaded = True
+            self._available = False
+            return
         model = SentenceTransformer(
             self._config.model_name, trust_remote_code=False,
         )

package/src/superlocalmemory/core/engine.py

@@ -81,7 +81,12 @@ class MemoryEngine:
 
         self._db = DatabaseManager(self._config.db_path)
         self._db.initialize(schema)
-        self._embedder = EmbeddingService(self._config.embedding)
+        try:
+            emb = EmbeddingService(self._config.embedding)
+            self._embedder = emb if emb.is_available else None
+        except Exception as exc:
+            logger.warning("Embeddings unavailable (%s). BM25-only mode.", exc)
+            self._embedder = None
 
         if self._caps.llm_fact_extraction:
             self._llm = LLMBackbone(self._config.llm)

package/src/superlocalmemory/encoding/entropy_gate.py

@@ -68,24 +68,21 @@ class EntropyGate:
             logger.debug("Entropy gate: blocked (low-info pattern: '%s')", normalized)
             return False
 
-        # Stage 2: Similarity-based deduplication
-        if self._embedder is not None and self._recent_embeddings:
+        # Stage 2: Similarity-based deduplication (requires embeddings)
+        if self._embedder is not None:
             emb = self._embedder.embed(content)
-            for recent in self._recent_embeddings:
-                sim = _cosine(emb, recent)
-                if sim > self._threshold:
-                    logger.debug(
-                        "Entropy gate: blocked (near-duplicate, sim=%.3f)", sim
-                    )
-                    return False
-            # Add to window
-            self._recent_embeddings.append(emb)
-            if len(self._recent_embeddings) > self._window_size:
-                self._recent_embeddings.pop(0)
-        elif self._embedder is not None:
-            # First content — add to window, always pass
-            emb = self._embedder.embed(content)
-            self._recent_embeddings.append(emb)
+            if emb is not None:
+                if self._recent_embeddings:
+                    for recent in self._recent_embeddings:
+                        sim = _cosine(emb, recent)
+                        if sim > self._threshold:
+                            logger.debug(
+                                "Entropy gate: blocked (near-duplicate, sim=%.3f)", sim
+                            )
+                            return False
+                self._recent_embeddings.append(emb)
+                if len(self._recent_embeddings) > self._window_size:
+                    self._recent_embeddings.pop(0)
 
         return True
 

package/src/superlocalmemory/storage/v2_migrator.py

@@ -240,24 +240,70 @@ class V2Migrator:
             shutil.copy2(str(self._v2_db), str(self._v3_db))
             stats["steps"].append("Copied database to V3 location")
 
-            # Step 4: Extend schema
+            # Step 4: Extend schema + alter V2 tables for V3 compatibility
             conn = sqlite3.connect(str(self._v3_db))
-            for sql in V3_TABLES_SQL:
-                conn.execute(sql)
-            for sql in V3_INDEXES_SQL:
-                conn.execute(sql)
-            # Mark migration
-            conn.execute(
-                "INSERT OR REPLACE INTO v3_config (key, value, updated_at) VALUES (?, ?, ?)",
-                ("migration_date", datetime.now(UTC).isoformat(), datetime.now(UTC).isoformat()),
-            )
-            conn.execute(
-                "INSERT OR REPLACE INTO v3_config (key, value, updated_at) VALUES (?, ?, ?)",
-                ("migration_version", "3.0.0", datetime.now(UTC).isoformat()),
-            )
+
+            # Add missing V3 columns to V2 memories table
+            existing_cols = {r[1] for r in conn.execute("PRAGMA table_info(memories)").fetchall()}
+            v3_columns = [
+                ("profile_id", 'TEXT DEFAULT "default"'),
+                ("memory_id", "TEXT"),
+                ("session_id", 'TEXT DEFAULT ""'),
+                ("speaker", 'TEXT DEFAULT ""'),
+                ("role", 'TEXT DEFAULT "user"'),
+                ("session_date", "TEXT"),
+                ("metadata_json", 'TEXT DEFAULT "{}"'),
+            ]
+            for col, coltype in v3_columns:
+                if col not in existing_cols:
+                    conn.execute(f"ALTER TABLE memories ADD COLUMN {col} {coltype}")
+            # Backfill V3 columns from V2 data
+            conn.execute('UPDATE memories SET profile_id = COALESCE(profile, "default") WHERE profile_id IS NULL')
+            conn.execute("UPDATE memories SET memory_id = 'v2_' || CAST(id AS TEXT) WHERE memory_id IS NULL")
+            # Create unique index on memory_id so V3 FKs work
+            try:
+                conn.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_memories_memory_id ON memories (memory_id)")
+            except Exception:
+                pass
+            # Disable FK enforcement for migrated DBs (V2 schema is incompatible)
+            conn.execute("PRAGMA foreign_keys=OFF")
+
+            # Rename ALL tables with incompatible schemas (V2 + old alpha)
+            # User data is in 'memories' table (already upgraded above)
+            # Everything else is computed/derived and will be recreated by V3
+            all_existing = {r[0] for r in conn.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '_v2_bak_%'"
+            ).fetchall()}
+            # Keep only: memories (upgraded), profiles, schema_version, v3_config, sqlite_sequence
+            keep_tables = {"memories", "profiles", "schema_version", "v3_config", "sqlite_sequence"}
+            v2_conflicting = [t for t in all_existing if t not in keep_tables and not t.startswith("_")]
+            for table in v2_conflicting:
+                try:
+                    conn.execute(f'ALTER TABLE "{table}" RENAME TO "_v2_bak_{table}"')
+                except Exception:
+                    pass  # Table may not exist
+
             conn.commit()
+
+            # Use the FULL V3 schema (not the partial V3_TABLES_SQL)
+            from superlocalmemory.storage import schema
+            schema.create_all_tables(conn)
+            conn.commit()
+            # Mark migration in config table
+            try:
+                conn.execute(
+                    "INSERT OR REPLACE INTO config (key, value, updated_at) VALUES (?, ?, ?)",
+                    ("migration_date", datetime.now(UTC).isoformat(), datetime.now(UTC).isoformat()),
+                )
+                conn.execute(
+                    "INSERT OR REPLACE INTO config (key, value, updated_at) VALUES (?, ?, ?)",
+                    ("migration_version", "3.0.0", datetime.now(UTC).isoformat()),
+                )
+                conn.commit()
+            except Exception:
+                pass  # Schema handles this on engine init
             conn.close()
-            stats["steps"].append(f"Extended schema ({len(V3_TABLES_SQL)} tables, {len(V3_INDEXES_SQL)} indexes)")
+            stats["steps"].append("Created V3 schema")
 
             # Step 5: Symlink (only if .claude-memory is not already a symlink)
             if not self._v2_base.is_symlink():