superlocalmemory 2.8.3 → 2.8.5

package/ATTRIBUTION.md

@@ -38,7 +38,7 @@ is_valid = QualixarSigner.verify(signed_output)
 
 ### Research Initiative
 
-Qualixar is a research platform for AI agent development tools. SuperLocalMemory is one of several research initiatives under the Qualixar umbrella. For more information, visit qualixar.com.
+Qualixar is a research initiative for AI agent development tools by Varun Pratap Bhardwaj. SuperLocalMemory is one of several research initiatives under the Qualixar umbrella.
 
 ### Third-Party Acknowledgments
 

package/CHANGELOG.md

@@ -16,6 +16,23 @@ SuperLocalMemory V2 - Intelligent local memory system for AI coding assistants.
 
 ---
 
+## [2.8.3] - 2026-03-05
+
+### Fixed
+- Windows installation and cross-platform compatibility
+- Database stability under concurrent usage
+- Forward compatibility with latest Python versions
+
+### Added
+- Full Windows support with PowerShell scripts for all operations
+- `slm attribution` command for license and creator information
+
+### Improved
+- Overall reliability and code quality
+- Dependency management for reproducible installs
+
+---
+
 ## [2.8.2] - 2026-03-04
 
 ### Fixed

package/bin/slm

@@ -310,6 +310,38 @@ except Exception as e:
 "
         ;;
 
+    attribution)
+        python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+try:
+    from memory_store_v2 import MemoryStoreV2
+    store = MemoryStoreV2()
+    attr = store.get_attribution()
+    print('SuperLocalMemory — Attribution')
+    print('=' * 45)
+    print(f\"Creator:  {attr.get('creator_name', 'Varun Pratap Bhardwaj')}\")
+    print(f\"Role:     {attr.get('creator_role', 'Solution Architect')}\")
+    print(f\"Platform: {attr.get('platform', 'Qualixar')}\")
+    print(f\"License:  {attr.get('license', 'MIT')}\")
+    print(f\"Website:  {attr.get('website', 'https://superlocalmemory.com')}\")
+    print(f\"Author:   {attr.get('author_website', 'https://varunpratap.com')}\")
+    print('=' * 45)
+    try:
+        from qualixar_attribution import QualixarSigner
+        from qualixar_watermark import encode_watermark
+        print('Layer 1 (Visible):        Active')
+        print('Layer 2 (Cryptographic):  Active')
+        print('Layer 3 (Steganographic): Active')
+    except ImportError:
+        print('Layer 1 (Visible):        Active')
+        print('Layer 2 (Cryptographic):  Not available')
+        print('Layer 3 (Steganographic): Not available')
+except Exception as e:
+    print(f'Error: {e}')
+"
+        ;;
+
     help|--help|-h)
         cat <<EOF
 SuperLocalMemory V2 - Universal CLI
@@ -356,6 +388,9 @@ HTTP SERVER (MCP):
   slm serve [PORT]         Start MCP HTTP server (default port 8417)
                            For ChatGPT/remote: ngrok http PORT
 
+ATTRIBUTION:
+  slm attribution          Show creator attribution and provenance status
+
 ADVANCED:
   slm reset soft           Soft reset (clear memories)
   slm reset hard --confirm Hard reset (nuclear option)

package/mcp_server.py

@@ -61,6 +61,26 @@ try:
 except ImportError:
     TRUST_AVAILABLE = False
 
+# Qualixar Attribution (v2.8.3 — 3-layer provenance)
+try:
+    from qualixar_attribution import QualixarSigner
+    from qualixar_watermark import encode_watermark
+    _signer = QualixarSigner("superlocalmemory", "2.8.3")
+    ATTRIBUTION_AVAILABLE = True
+except ImportError:
+    _signer = None
+    ATTRIBUTION_AVAILABLE = False
+
+
+def _sign_response(response: dict) -> dict:
+    """Apply Layer 2 cryptographic signing to MCP tool responses."""
+    if _signer and isinstance(response, dict):
+        try:
+            return _signer.sign(response)
+        except Exception:
+            pass
+    return response
+
 # Learning System (v2.7+)
 try:
     sys.path.insert(0, str(Path(__file__).parent / "src"))
@@ -676,12 +696,12 @@ async def remember(
         # Format response
         preview = content[:100] + "..." if len(content) > 100 else content
 
-        return {
+        return _sign_response({
             "success": True,
             "memory_id": memory_id,
             "message": f"Memory saved with ID {memory_id}",
             "content_preview": preview
-        }
+        })
 
     except Exception as e:
         return {
@@ -805,13 +825,13 @@ async def recall(
             if r.get('score', 0) >= min_score
         ]
 
-        return {
+        return _sign_response({
             "success": True,
             "query": query,
             "results": filtered_results,
             "count": len(filtered_results),
             "total_searched": len(results)
-        }
+        })
 
     except Exception as e:
         return {
@@ -888,10 +908,10 @@ async def get_status() -> dict:
         # Call existing get_stats method
         stats = store.get_stats()
 
-        return {
+        return _sign_response({
             "success": True,
             **stats
-        }
+        })
 
     except Exception as e:
         return {
@@ -1637,6 +1657,54 @@ async def project_context_prompt(project_name: str) -> str:
 # SERVER STARTUP
 # ============================================================================
 
+@mcp.tool(annotations=ToolAnnotations(
+    readOnlyHint=True,
+    destructiveHint=False,
+    openWorldHint=False,
+))
+async def get_attribution() -> dict:
+    """
+    Get creator attribution and provenance verification for SuperLocalMemory.
+
+    Returns creator information, license details, and verification status
+    for the 3-layer Qualixar attribution system.
+
+    Returns:
+        {
+            "creator": str,
+            "license": str,
+            "platform": str,
+            "layers": {
+                "visible": bool,
+                "cryptographic": bool,
+                "steganographic": bool
+            }
+        }
+    """
+    try:
+        store = get_store()
+        attribution = store.get_attribution()
+
+        return _sign_response({
+            "success": True,
+            **attribution,
+            "website": "https://superlocalmemory.com",
+            "author_website": "https://varunpratap.com",
+            "attribution_layers": {
+                "layer1_visible": True,
+                "layer2_cryptographic": ATTRIBUTION_AVAILABLE,
+                "layer3_steganographic": ATTRIBUTION_AVAILABLE,
+            },
+        })
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": _sanitize_error(e),
+            "message": "Failed to get attribution"
+        }
+
+
 if __name__ == "__main__":
     import argparse
 
@@ -1662,7 +1730,7 @@ if __name__ == "__main__":
     # Print startup message to stderr (stdout is used for MCP protocol)
     print("=" * 60, file=sys.stderr)
     print("SuperLocalMemory V2 - MCP Server", file=sys.stderr)
-    print("Version: 2.7.4", file=sys.stderr)
+    print("Version: 2.8.3", file=sys.stderr)
     print("=" * 60, file=sys.stderr)
     print("Created by: Varun Pratap Bhardwaj (Solution Architect)", file=sys.stderr)
     print("Repository: https://github.com/varun369/SuperLocalMemoryV2", file=sys.stderr)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "2.8.3",
+  "version": "2.8.5",
   "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 17+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",

package/src/memory_store_v2.py

@@ -1105,7 +1105,8 @@ class MemoryStoreV2:
 
         # Qualixar platform provenance (non-breaking additions)
         attribution['platform'] = 'Qualixar'
-        attribution['verify_url'] = 'https://qualixar.com'
+        attribution['website'] = 'https://superlocalmemory.com'
+        attribution['author_website'] = 'https://varunpratap.com'
 
         return attribution
 
@@ -1136,7 +1137,16 @@ class MemoryStoreV2:
             output.append(entry)
             char_count += len(entry)
 
-        return ''.join(output)
+        text = ''.join(output)
+
+        # Layer 3: Steganographic watermark on text exports
+        try:
+            from qualixar_watermark import encode_watermark
+            text = encode_watermark(text, "slm")
+        except ImportError:
+            pass
+
+        return text
 
 
 # CLI interface (V1 compatible + V2 extensions)