superlocalmemory 2.8.5 → 3.0.0

package/src/mcp_tools_v28.py

@@ -1,281 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""v2.8 MCP tool handlers — lifecycle, behavioral, compliance tools.
-
-These functions implement the 6 new MCP tools added in v2.8.
-They are registered with the MCP server in mcp_server.py.
-Each function is a thin wrapper around the appropriate engine.
-
-Tool list:
-    1. report_outcome        — Record action outcomes for behavioral learning
-    2. get_lifecycle_status   — View memory lifecycle states
-    3. set_retention_policy   — Configure compliance retention policies
-    4. compact_memories       — Trigger lifecycle transitions
-    5. get_behavioral_patterns — View learned behavioral patterns
-    6. audit_trail            — Query compliance audit trail
-"""
-import json
-import sys
-from pathlib import Path
-from typing import Optional, Dict, Any
-
-# Default database paths — overridable for testing
-DEFAULT_MEMORY_DB = str(Path.home() / ".claude-memory" / "memory.db")
-DEFAULT_LEARNING_DB = str(Path.home() / ".claude-memory" / "learning.db")
-DEFAULT_AUDIT_DB = str(Path.home() / ".claude-memory" / "audit.db")
-
-# Ensure src/ is on the path so subpackage imports work
-_SRC_DIR = str(Path(__file__).resolve().parent)
-if _SRC_DIR not in sys.path:
-    sys.path.insert(0, _SRC_DIR)
-
-
-async def report_outcome(
-    memory_ids: list,
-    outcome: str,
-    action_type: str = "other",
-    context: Optional[str] = None,
-    agent_id: str = "user",
-    project: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Record an action outcome for behavioral learning.
-
-    Args:
-        memory_ids: List of memory IDs involved in the action.
-        outcome: One of 'success', 'failure', or 'partial'.
-        action_type: Category (code_written, decision_made, debug_resolved, etc.).
-        context: Optional JSON string with additional context metadata.
-        agent_id: Identifier for the reporting agent.
-        project: Project name for scoping outcomes.
-
-    Returns:
-        Dict with success status and outcome_id on success.
-    """
-    try:
-        from behavioral.outcome_tracker import OutcomeTracker
-
-        tracker = OutcomeTracker(DEFAULT_LEARNING_DB)
-        ctx = json.loads(context) if context else {}
-        outcome_id = tracker.record_outcome(
-            memory_ids=memory_ids,
-            outcome=outcome,
-            action_type=action_type,
-            context=ctx,
-            agent_id=agent_id,
-            project=project,
-        )
-        if outcome_id is None:
-            return {
-                "success": False,
-                "error": f"Invalid outcome: {outcome}. Use success/failure/partial.",
-            }
-        return {
-            "success": True,
-            "outcome_id": outcome_id,
-            "outcome": outcome,
-            "memory_ids": memory_ids,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def get_lifecycle_status(
-    memory_id: Optional[int] = None,
-) -> Dict[str, Any]:
-    """Get lifecycle status — distribution across states or single memory state.
-
-    Args:
-        memory_id: Optional specific memory ID. If None, returns full distribution.
-
-    Returns:
-        Dict with state distribution or single memory lifecycle state.
-    """
-    try:
-        from lifecycle.lifecycle_engine import LifecycleEngine
-
-        engine = LifecycleEngine(DEFAULT_MEMORY_DB)
-        if memory_id is not None:
-            state = engine.get_memory_state(memory_id)
-            if state is None:
-                return {"success": False, "error": f"Memory {memory_id} not found"}
-            return {
-                "success": True,
-                "memory_id": memory_id,
-                "lifecycle_state": state,
-            }
-        else:
-            dist = engine.get_state_distribution()
-            total = sum(dist.values())
-            return {
-                "success": True,
-                "distribution": dist,
-                "total_memories": total,
-            }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def set_retention_policy(
-    name: str,
-    framework: str,
-    retention_days: int,
-    action: str = "retain",
-    applies_to_tags: Optional[list] = None,
-    applies_to_project: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Create a retention policy for compliance.
-
-    Args:
-        name: Policy name (e.g., 'GDPR Erasure', 'HIPAA Retention').
-        framework: Regulatory framework (gdpr, hipaa, eu_ai_act, internal).
-        retention_days: Days to retain (0 = immediate action).
-        action: Policy action (retain, tombstone, archive).
-        applies_to_tags: Tags that trigger this policy.
-        applies_to_project: Project name that triggers this policy.
-
-    Returns:
-        Dict with policy_id on success.
-    """
-    try:
-        from lifecycle.retention_policy import RetentionPolicyManager
-
-        mgr = RetentionPolicyManager(DEFAULT_MEMORY_DB)
-        applies_to: Dict[str, Any] = {}
-        if applies_to_tags:
-            applies_to["tags"] = applies_to_tags
-        if applies_to_project:
-            applies_to["project_name"] = applies_to_project
-        policy_id = mgr.create_policy(
-            name=name,
-            retention_days=retention_days,
-            framework=framework,
-            action=action,
-            applies_to=applies_to,
-        )
-        return {
-            "success": True,
-            "policy_id": policy_id,
-            "name": name,
-            "framework": framework,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def compact_memories(
-    dry_run: bool = True,
-    profile: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Evaluate and compact memories — transition stale ones through lifecycle.
-
-    Args:
-        dry_run: If True (default), show what would happen without changes.
-        profile: Optional profile filter to scope compaction.
-
-    Returns:
-        Dict with recommendations (dry_run=True) or transition counts (dry_run=False).
-    """
-    active_profile = profile
-    try:
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        from lifecycle.lifecycle_engine import LifecycleEngine
-
-        evaluator = LifecycleEvaluator(DEFAULT_MEMORY_DB)
-        recommendations = evaluator.evaluate_memories(profile=active_profile)
-
-        if dry_run:
-            return {
-                "success": True,
-                "dry_run": True,
-                "recommendations": len(recommendations),
-                "details": [
-                    {
-                        "memory_id": r["memory_id"],
-                        "from": r["from_state"],
-                        "to": r["to_state"],
-                        "reason": r["reason"],
-                    }
-                    for r in recommendations[:20]
-                ],
-            }
-
-        engine = LifecycleEngine(DEFAULT_MEMORY_DB)
-        transitioned = 0
-        for rec in recommendations:
-            result = engine.transition_memory(
-                rec["memory_id"], rec["to_state"], reason=rec["reason"]
-            )
-            if result.get("success"):
-                transitioned += 1
-
-        return {
-            "success": True,
-            "dry_run": False,
-            "evaluated": len(recommendations),
-            "transitioned": transitioned,
-        }
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def get_behavioral_patterns(
-    min_confidence: float = 0.0,
-    project: Optional[str] = None,
-) -> Dict[str, Any]:
-    """Get learned behavioral patterns from outcome analysis.
-
-    Args:
-        min_confidence: Minimum confidence threshold (0.0-1.0).
-        project: Optional project filter.
-
-    Returns:
-        Dict with patterns list and count.
-    """
-    try:
-        from behavioral.behavioral_patterns import BehavioralPatternExtractor
-
-        extractor = BehavioralPatternExtractor(DEFAULT_LEARNING_DB)
-        patterns = extractor.get_patterns(
-            min_confidence=min_confidence, project=project
-        )
-        return {"success": True, "patterns": patterns, "count": len(patterns)}
-    except Exception as e:
-        return {"success": False, "error": str(e)}
-
-
-async def audit_trail(
-    event_type: Optional[str] = None,
-    actor: Optional[str] = None,
-    limit: int = 50,
-    verify_chain: bool = False,
-) -> Dict[str, Any]:
-    """Query the compliance audit trail.
-
-    Args:
-        event_type: Filter by event type (memory.created, memory.recalled, etc.).
-        actor: Filter by actor (user, agent_id, etc.).
-        limit: Max events to return.
-        verify_chain: If True, verify hash chain integrity.
-
-    Returns:
-        Dict with events list, count, and optional chain verification result.
-    """
-    try:
-        from compliance.audit_db import AuditDB
-
-        db = AuditDB(DEFAULT_AUDIT_DB)
-        result: Dict[str, Any] = {"success": True}
-
-        if verify_chain:
-            chain_result = db.verify_chain()
-            result["chain_valid"] = chain_result["valid"]
-            result["chain_entries"] = chain_result["entries_checked"]
-
-        events = db.query_events(
-            event_type=event_type, actor=actor, limit=limit
-        )
-        result["events"] = events
-        result["count"] = len(events)
-        return result
-    except Exception as e:
-        return {"success": False, "error": str(e)}

package/src/memory/__init__.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Memory package - Constants, schema, and utilities for MemoryStoreV2.
-
-This package contains extracted utilities from memory_store_v2.py to keep
-the main class focused and under the 800-line target.
-"""
-
-from .constants import (
-    MEMORY_DIR,
-    DB_PATH,
-    VECTORS_PATH,
-    MAX_CONTENT_SIZE,
-    MAX_SUMMARY_SIZE,
-    MAX_TAG_LENGTH,
-    MAX_TAGS,
-    CREATOR_METADATA,
-)
-
-from .helpers import format_content
-from .cli import run_cli
-
-__all__ = [
-    'MEMORY_DIR',
-    'DB_PATH',
-    'VECTORS_PATH',
-    'MAX_CONTENT_SIZE',
-    'MAX_SUMMARY_SIZE',
-    'MAX_TAG_LENGTH',
-    'MAX_TAGS',
-    'CREATOR_METADATA',
-    'format_content',
-    'run_cli',
-]

package/src/memory/cli.py

@@ -1,205 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Command-line interface for MemoryStoreV2.
-
-This module contains the CLI implementation extracted from memory_store_v2.py
-to reduce file size and improve maintainability.
-"""
-
-import sys
-import json
-from .helpers import format_content
-
-
-def run_cli():
-    """Main CLI entry point for MemoryStoreV2."""
-    # Import here to avoid circular dependency
-    from memory_store_v2 import MemoryStoreV2
-
-    store = MemoryStoreV2()
-
-    if len(sys.argv) < 2:
-        print("MemoryStore V2 CLI")
-        print("\nV1 Compatible Commands:")
-        print("  python memory_store_v2.py add <content> [--project <path>] [--tags tag1,tag2]")
-        print("  python memory_store_v2.py search <query> [--full]")
-        print("  python memory_store_v2.py list [limit] [--full]")
-        print("  python memory_store_v2.py get <id>")
-        print("  python memory_store_v2.py recent [limit] [--full]")
-        print("  python memory_store_v2.py stats")
-        print("  python memory_store_v2.py context <query>")
-        print("  python memory_store_v2.py delete <id>")
-        print("\nV2 Extensions:")
-        print("  python memory_store_v2.py tree [parent_id]")
-        print("  python memory_store_v2.py cluster <cluster_id> [--full]")
-        print("\nOptions:")
-        print("  --full    Show complete content (default: smart truncation at 5000 chars)")
-        sys.exit(0)
-
-    command = sys.argv[1]
-
-    if command == "tree":
-        parent_id = int(sys.argv[2]) if len(sys.argv) > 2 else None
-        results = store.get_tree(parent_id)
-
-        if not results:
-            print("No memories in tree.")
-        else:
-            for r in results:
-                indent = "  " * r['depth']
-                print(f"{indent}[{r['id']}] {r['content'][:50]}...")
-                if r.get('category'):
-                    print(f"{indent}    Category: {r['category']}")
-
-    elif command == "cluster" and len(sys.argv) >= 3:
-        cluster_id = int(sys.argv[2])
-        show_full = '--full' in sys.argv
-        results = store.get_by_cluster(cluster_id)
-
-        if not results:
-            print(f"No memories in cluster {cluster_id}.")
-        else:
-            print(f"Cluster {cluster_id} - {len(results)} memories:")
-            for r in results:
-                print(f"\n[{r['id']}] Importance: {r['importance']}")
-                print(f"  {format_content(r['content'], full=show_full)}")
-
-    elif command == "stats":
-        stats = store.get_stats()
-        print(json.dumps(stats, indent=2))
-
-    elif command == "add":
-        # Parse content and options
-        if len(sys.argv) < 3:
-            print("Error: Content required")
-            print("Usage: python memory_store_v2.py add <content> [--project <path>] [--tags tag1,tag2]")
-            sys.exit(1)
-
-        content = sys.argv[2]
-        project_path = None
-        tags = []
-
-        i = 3
-        while i < len(sys.argv):
-            if sys.argv[i] == '--project' and i + 1 < len(sys.argv):
-                project_path = sys.argv[i + 1]
-                i += 2
-            elif sys.argv[i] == '--tags' and i + 1 < len(sys.argv):
-                tags = [t.strip() for t in sys.argv[i + 1].split(',')]
-                i += 2
-            else:
-                i += 1
-
-        mem_id = store.add_memory(content, project_path=project_path, tags=tags)
-        print(f"Memory added with ID: {mem_id}")
-
-    elif command == "search":
-        if len(sys.argv) < 3:
-            print("Error: Search query required")
-            print("Usage: python memory_store_v2.py search <query> [--full]")
-            sys.exit(1)
-
-        query = sys.argv[2]
-        show_full = '--full' in sys.argv
-        results = store.search(query, limit=5)
-
-        if not results:
-            print("No results found.")
-        else:
-            for r in results:
-                print(f"\n[{r['id']}] Score: {r['score']:.2f}")
-                if r.get('project_name'):
-                    print(f"Project: {r['project_name']}")
-                if r.get('tags'):
-                    print(f"Tags: {', '.join(r['tags'])}")
-                print(f"Content: {format_content(r['content'], full=show_full)}")
-                print(f"Created: {r['created_at']}")
-
-    elif command == "recent":
-        show_full = '--full' in sys.argv
-        # Parse limit (skip --full flag)
-        limit = 10
-        for i, arg in enumerate(sys.argv[2:], start=2):
-            if arg != '--full' and arg.isdigit():
-                limit = int(arg)
-                break
-
-        results = store.get_recent(limit)
-
-        if not results:
-            print("No memories found.")
-        else:
-            for r in results:
-                print(f"\n[{r['id']}] {r['created_at']}")
-                if r.get('project_name'):
-                    print(f"Project: {r['project_name']}")
-                if r.get('tags'):
-                    print(f"Tags: {', '.join(r['tags'])}")
-                print(f"Content: {format_content(r['content'], full=show_full)}")
-
-    elif command == "list":
-        show_full = '--full' in sys.argv
-        # Parse limit (skip --full flag)
-        limit = 10
-        for i, arg in enumerate(sys.argv[2:], start=2):
-            if arg != '--full' and arg.isdigit():
-                limit = int(arg)
-                break
-
-        results = store.get_recent(limit)
-
-        if not results:
-            print("No memories found.")
-        else:
-            for r in results:
-                print(f"[{r['id']}] {format_content(r['content'], full=show_full)}")
-
-    elif command == "get":
-        if len(sys.argv) < 3:
-            print("Error: Memory ID required")
-            print("Usage: python memory_store_v2.py get <id>")
-            sys.exit(1)
-
-        mem_id = int(sys.argv[2])
-        memory = store.get_by_id(mem_id)
-
-        if not memory:
-            print(f"Memory {mem_id} not found.")
-        else:
-            print(f"\nID: {memory['id']}")
-            print(f"Content: {memory['content']}")
-            if memory.get('summary'):
-                print(f"Summary: {memory['summary']}")
-            if memory.get('project_name'):
-                print(f"Project: {memory['project_name']}")
-            if memory.get('tags'):
-                print(f"Tags: {', '.join(memory['tags'])}")
-            print(f"Created: {memory['created_at']}")
-            print(f"Importance: {memory['importance']}")
-            print(f"Access Count: {memory['access_count']}")
-
-    elif command == "context":
-        if len(sys.argv) < 3:
-            print("Error: Query required")
-            print("Usage: python memory_store_v2.py context <query>")
-            sys.exit(1)
-
-        query = sys.argv[2]
-        context = store.export_for_context(query)
-        print(context)
-
-    elif command == "delete":
-        if len(sys.argv) < 3:
-            print("Error: Memory ID required")
-            print("Usage: python memory_store_v2.py delete <id>")
-            sys.exit(1)
-
-        mem_id = int(sys.argv[2])
-        store.delete_memory(mem_id)
-        print(f"Memory {mem_id} deleted.")
-
-    else:
-        print(f"Unknown command: {command}")
-        print("Run without arguments to see available commands.")

package/src/memory/constants.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Constants and configuration values for MemoryStoreV2.
-
-This module contains all module-level constants extracted from memory_store_v2.py
-to reduce file size and improve maintainability.
-"""
-
-from pathlib import Path
-
-# Database paths
-MEMORY_DIR = Path.home() / ".claude-memory"
-DB_PATH = MEMORY_DIR / "memory.db"
-VECTORS_PATH = MEMORY_DIR / "vectors"
-
-# Security: Input validation limits
-MAX_CONTENT_SIZE = 1_000_000    # 1MB max content
-MAX_SUMMARY_SIZE = 10_000       # 10KB max summary
-MAX_TAG_LENGTH = 50             # 50 chars per tag
-MAX_TAGS = 20                   # 20 tags max
-
-# Creator Attribution Metadata (REQUIRED by MIT License)
-# This data is embedded in the database creator_metadata table
-CREATOR_METADATA = {
-    'creator_name': 'Varun Pratap Bhardwaj',
-    'creator_role': 'Solution Architect & Original Creator',
-    'creator_github': 'varun369',
-    'project_name': 'SuperLocalMemory V2',
-    'project_url': 'https://github.com/varun369/SuperLocalMemoryV2',
-    'license': 'MIT',
-    'attribution_required': 'yes',
-    'version': '2.5.0',
-    'architecture_date': '2026-01-15',
-    'release_date': '2026-02-07',
-    'signature': 'VBPB-SLM-V2-2026-ARCHITECT',
-    'verification_hash': 'sha256:c9f3d1a8b5e2f4c6d8a9b3e7f1c4d6a8b9c3e7f2d5a8c1b4e6f9d2a7c5b8e1'
-}

package/src/memory/helpers.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Helper utilities for MemoryStoreV2.
-
-This module contains standalone utility functions extracted from memory_store_v2.py
-to reduce file size and improve maintainability.
-"""
-
-
-def format_content(content: str, full: bool = False, threshold: int = 5000, preview_len: int = 2000) -> str:
-    """
-    Smart content formatting with optional truncation.
-
-    Args:
-        content: Content to format
-        full: If True, always show full content
-        threshold: Max length before truncation (default 5000)
-        preview_len: Preview length when truncating (default 2000)
-
-    Returns:
-        Formatted content string
-    """
-    if full or len(content) < threshold:
-        return content
-    else:
-        return f"{content[:preview_len]}..."