superlocalmemory 2.8.2 → 2.8.5

package/src/memory/helpers.py

@@ -0,0 +1,28 @@
+#!/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]}..."

package/src/memory/schema.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""
+Database schema definitions for MemoryStoreV2.
+
+This module contains SQL schema definitions and migration logic extracted from
+memory_store_v2.py to reduce file size and improve maintainability.
+"""
+
+from typing import Dict, List, Tuple
+
+
+# V2 column definitions for migration support
+V2_COLUMNS: Dict[str, str] = {
+    'summary': 'TEXT',
+    'project_path': 'TEXT',
+    'project_name': 'TEXT',
+    'category': 'TEXT',
+    'parent_id': 'INTEGER',
+    'tree_path': 'TEXT',
+    'depth': 'INTEGER DEFAULT 0',
+    'memory_type': 'TEXT DEFAULT "session"',
+    'importance': 'INTEGER DEFAULT 5',
+    'updated_at': 'TIMESTAMP DEFAULT CURRENT_TIMESTAMP',
+    'last_accessed': 'TIMESTAMP',
+    'access_count': 'INTEGER DEFAULT 0',
+    'content_hash': 'TEXT',
+    'cluster_id': 'INTEGER',
+    'profile': 'TEXT DEFAULT "default"'
+}
+
+# v2.8.0 schema migrations - lifecycle + access control columns
+V28_MIGRATIONS: List[Tuple[str, str]] = [
+    ("lifecycle_state", "TEXT DEFAULT 'active'"),
+    ("lifecycle_updated_at", "TIMESTAMP"),
+    ("lifecycle_history", "TEXT DEFAULT '[]'"),
+    ("access_level", "TEXT DEFAULT 'public'"),
+]
+
+# Index definitions for V2 fields
+V2_INDEXES: List[Tuple[str, str]] = [
+    ('idx_project', 'project_path'),
+    ('idx_tags', 'tags'),
+    ('idx_category', 'category'),
+    ('idx_tree_path', 'tree_path'),
+    ('idx_cluster', 'cluster_id'),
+    ('idx_last_accessed', 'last_accessed'),
+    ('idx_parent_id', 'parent_id'),
+    ('idx_profile', 'profile')
+]
+
+
+def get_memories_table_sql() -> str:
+    """
+    Returns the CREATE TABLE SQL for the main memories table.
+    V1 compatible + V2 extensions.
+    """
+    return '''
+        CREATE TABLE IF NOT EXISTS memories (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            content TEXT NOT NULL,
+            summary TEXT,
+
+            -- Organization
+            project_path TEXT,
+            project_name TEXT,
+            tags TEXT,
+            category TEXT,
+
+            -- Hierarchy (Layer 2 link)
+            parent_id INTEGER,
+            tree_path TEXT,
+            depth INTEGER DEFAULT 0,
+
+            -- Metadata
+            memory_type TEXT DEFAULT 'session',
+            importance INTEGER DEFAULT 5,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            last_accessed TIMESTAMP,
+            access_count INTEGER DEFAULT 0,
+
+            -- Deduplication
+            content_hash TEXT UNIQUE,
+
+            -- Graph (Layer 3 link)
+            cluster_id INTEGER,
+
+            FOREIGN KEY (parent_id) REFERENCES memories(id) ON DELETE CASCADE
+        )
+    '''
+
+
+def get_sessions_table_sql() -> str:
+    """
+    Returns the CREATE TABLE SQL for the sessions table.
+    V1 compatible.
+    """
+    return '''
+        CREATE TABLE IF NOT EXISTS sessions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT UNIQUE,
+            project_path TEXT,
+            started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            ended_at TIMESTAMP,
+            summary TEXT
+        )
+    '''
+
+
+def get_fts_table_sql() -> str:
+    """
+    Returns the CREATE VIRTUAL TABLE SQL for full-text search.
+    V1 compatible.
+    """
+    return '''
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts
+        USING fts5(content, summary, tags, content='memories', content_rowid='id')
+    '''
+
+
+def get_fts_trigger_insert_sql() -> str:
+    """Returns the FTS INSERT trigger SQL."""
+    return '''
+        CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+            INSERT INTO memories_fts(rowid, content, summary, tags)
+            VALUES (new.id, new.content, new.summary, new.tags);
+        END
+    '''
+
+
+def get_fts_trigger_delete_sql() -> str:
+    """Returns the FTS DELETE trigger SQL."""
+    return '''
+        CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+            INSERT INTO memories_fts(memories_fts, rowid, content, summary, tags)
+            VALUES('delete', old.id, old.content, old.summary, old.tags);
+        END
+    '''
+
+
+def get_fts_trigger_update_sql() -> str:
+    """Returns the FTS UPDATE trigger SQL."""
+    return '''
+        CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+            INSERT INTO memories_fts(memories_fts, rowid, content, summary, tags)
+            VALUES('delete', old.id, old.content, old.summary, old.tags);
+            INSERT INTO memories_fts(rowid, content, summary, tags)
+            VALUES (new.id, new.content, new.summary, new.tags);
+        END
+    '''
+
+
+def get_creator_metadata_table_sql() -> str:
+    """
+    Returns the CREATE TABLE SQL for creator attribution metadata.
+    REQUIRED by MIT License.
+    """
+    return '''
+        CREATE TABLE IF NOT EXISTS creator_metadata (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    '''

package/src/memory-profiles.py

@@ -128,74 +128,74 @@ class ProfileManager:
         main_cursor = main_conn.cursor()
 
         old_conn = sqlite3.connect(old_db_path)
-        old_cursor = old_conn.cursor()
-
-        # Get existing hashes
-        main_cursor.execute("SELECT content_hash FROM memories WHERE content_hash IS NOT NULL")
-        existing_hashes = {row[0] for row in main_cursor.fetchall()}
-
-        # Get columns from old DB
-        old_cursor.execute("PRAGMA table_info(memories)")
-        old_columns = {row[1] for row in old_cursor.fetchall()}
-
-        # Build SELECT based on available columns
-        select_cols = ['content', 'summary', 'project_path', 'project_name', 'tags',
-                       'category', 'memory_type', 'importance', 'created_at', 'updated_at',
-                       'content_hash']
-        available_cols = [c for c in select_cols if c in old_columns]
-
-        if 'content' not in available_cols:
+        try:
+            old_cursor = old_conn.cursor()
+
+            # Get existing hashes
+            main_cursor.execute("SELECT content_hash FROM memories WHERE content_hash IS NOT NULL")
+            existing_hashes = {row[0] for row in main_cursor.fetchall()}
+
+            # Get columns from old DB
+            old_cursor.execute("PRAGMA table_info(memories)")
+            old_columns = {row[1] for row in old_cursor.fetchall()}
+
+            # Build SELECT based on available columns
+            select_cols = ['content', 'summary', 'project_path', 'project_name', 'tags',
+                           'category', 'memory_type', 'importance', 'created_at', 'updated_at',
+                           'content_hash']
+            available_cols = [c for c in select_cols if c in old_columns]
+
+            if 'content' not in available_cols:
+                return
+
+            old_cursor.execute(f"SELECT {', '.join(available_cols)} FROM memories")
+            rows = old_cursor.fetchall()
+
+            imported = 0
+            for row in rows:
+                row_dict = dict(zip(available_cols, row))
+                content = row_dict.get('content', '')
+                content_hash = row_dict.get('content_hash')
+
+                if not content:
+                    continue
+
+                # Generate hash if missing
+                if not content_hash:
+                    content_hash = hashlib.sha256(content.encode()).hexdigest()[:32]
+
+                if content_hash in existing_hashes:
+                    continue
+
+                try:
+                    main_cursor.execute('''
+                        INSERT INTO memories (content, summary, project_path, project_name, tags,
+                                              category, memory_type, importance, created_at, updated_at,
+                                              content_hash, profile)
+                        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    ''', (
+                        content,
+                        row_dict.get('summary'),
+                        row_dict.get('project_path'),
+                        row_dict.get('project_name'),
+                        row_dict.get('tags'),
+                        row_dict.get('category'),
+                        row_dict.get('memory_type', 'session'),
+                        row_dict.get('importance', 5),
+                        row_dict.get('created_at'),
+                        row_dict.get('updated_at'),
+                        content_hash,
+                        profile_name
+                    ))
+                    imported += 1
+                    existing_hashes.add(content_hash)
+                except sqlite3.IntegrityError:
+                    pass
+
+            main_conn.commit()
+        finally:
             old_conn.close()
             main_conn.close()
-            return
-
-        old_cursor.execute(f"SELECT {', '.join(available_cols)} FROM memories")
-        rows = old_cursor.fetchall()
-
-        imported = 0
-        for row in rows:
-            row_dict = dict(zip(available_cols, row))
-            content = row_dict.get('content', '')
-            content_hash = row_dict.get('content_hash')
-
-            if not content:
-                continue
-
-            # Generate hash if missing
-            if not content_hash:
-                content_hash = hashlib.sha256(content.encode()).hexdigest()[:32]
-
-            if content_hash in existing_hashes:
-                continue
-
-            try:
-                main_cursor.execute('''
-                    INSERT INTO memories (content, summary, project_path, project_name, tags,
-                                          category, memory_type, importance, created_at, updated_at,
-                                          content_hash, profile)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ''', (
-                    content,
-                    row_dict.get('summary'),
-                    row_dict.get('project_path'),
-                    row_dict.get('project_name'),
-                    row_dict.get('tags'),
-                    row_dict.get('category'),
-                    row_dict.get('memory_type', 'session'),
-                    row_dict.get('importance', 5),
-                    row_dict.get('created_at'),
-                    row_dict.get('updated_at'),
-                    content_hash,
-                    profile_name
-                ))
-                imported += 1
-                existing_hashes.add(content_hash)
-            except sqlite3.IntegrityError:
-                pass
-
-        main_conn.commit()
-        old_conn.close()
-        main_conn.close()
 
         if imported > 0:
             # Add profile to config if not present
@@ -257,17 +257,19 @@ class ProfileManager:
             return 0
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute("SELECT COUNT(*) FROM memories WHERE profile = ?", (profile_name,))
-        count = cursor.fetchone()[0]
-        conn.close()
+        try:
+            cursor = conn.cursor()
+            cursor.execute("SELECT COUNT(*) FROM memories WHERE profile = ?", (profile_name,))
+            count = cursor.fetchone()[0]
+        finally:
+            conn.close()
         return count
 
-    def get_active_profile(self):
+    def get_active_profile(self) -> str:
         """Get the currently active profile name."""
         return self.config.get('active_profile', 'default')
 
-    def list_profiles(self):
+    def list_profiles(self) -> list:
         """List all available profiles with memory counts."""
         print("\n" + "=" * 60)
         print("AVAILABLE MEMORY PROFILES")
@@ -410,11 +412,13 @@ class ProfileManager:
         # Move memories to default profile
         if self.db_path.exists() and count > 0:
             conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            cursor.execute("UPDATE memories SET profile = 'default' WHERE profile = ?", (name,))
-            moved = cursor.rowcount
-            conn.commit()
-            conn.close()
+            try:
+                cursor = conn.cursor()
+                cursor.execute("UPDATE memories SET profile = 'default' WHERE profile = ?", (name,))
+                moved = cursor.rowcount
+                conn.commit()
+            finally:
+                conn.close()
             print(f"  Moved {moved} memories to 'default' profile")
 
         # Remove from config
@@ -445,10 +449,12 @@ class ProfileManager:
             # Show total memories across all profiles
             if self.db_path.exists():
                 conn = sqlite3.connect(self.db_path)
-                cursor = conn.cursor()
-                cursor.execute("SELECT COUNT(*) FROM memories")
-                total = cursor.fetchone()[0]
-                conn.close()
+                try:
+                    cursor = conn.cursor()
+                    cursor.execute("SELECT COUNT(*) FROM memories")
+                    total = cursor.fetchone()[0]
+                finally:
+                    conn.close()
                 print(f"Total memories (all profiles): {total}")
         else:
             print(f"Warning: Current profile '{active}' not found in config")
@@ -475,11 +481,13 @@ class ProfileManager:
         # Update profile column in all memories
         if self.db_path.exists():
             conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            cursor.execute("UPDATE memories SET profile = ? WHERE profile = ?", (new_name, old_name))
-            updated = cursor.rowcount
-            conn.commit()
-            conn.close()
+            try:
+                cursor = conn.cursor()
+                cursor.execute("UPDATE memories SET profile = ? WHERE profile = ?", (new_name, old_name))
+                updated = cursor.rowcount
+                conn.commit()
+            finally:
+                conn.close()
             print(f"  Updated {updated} memories")
 
         # Update config