superlocalmemory 2.8.1 → 2.8.3

package/src/subscription_manager.py

@@ -53,7 +53,7 @@ class SubscriptionManager:
             return cls._instances[key]
 
     @classmethod
-    def reset_instance(cls, db_path: Optional[Path] = None):
+    def reset_instance(cls, db_path: Optional[Path] = None) -> None:
         """Remove singleton. Used for testing."""
         with cls._instances_lock:
             if db_path is None:
@@ -103,22 +103,24 @@ class SubscriptionManager:
         except ImportError:
             import sqlite3
             conn = sqlite3.connect(str(self.db_path))
-            conn.execute('''
-                CREATE TABLE IF NOT EXISTS subscriptions (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    subscriber_id TEXT NOT NULL UNIQUE,
-                    channel TEXT NOT NULL,
-                    filter TEXT NOT NULL DEFAULT '{}',
-                    webhook_url TEXT,
-                    durable INTEGER DEFAULT 1,
-                    last_event_id INTEGER DEFAULT 0,
-                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                )
-            ''')
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_subs_channel ON subscriptions(channel)')
-            conn.commit()
-            conn.close()
+            try:
+                conn.execute('''
+                    CREATE TABLE IF NOT EXISTS subscriptions (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        subscriber_id TEXT NOT NULL UNIQUE,
+                        channel TEXT NOT NULL,
+                        filter TEXT NOT NULL DEFAULT '{}',
+                        webhook_url TEXT,
+                        durable INTEGER DEFAULT 1,
+                        last_event_id INTEGER DEFAULT 0,
+                        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                    )
+                ''')
+                conn.execute('CREATE INDEX IF NOT EXISTS idx_subs_channel ON subscriptions(channel)')
+                conn.commit()
+            finally:
+                conn.close()
 
     # =========================================================================
     # Subscribe / Unsubscribe
@@ -244,7 +246,7 @@ class SubscriptionManager:
 
         return removed
 
-    def update_last_event_id(self, subscriber_id: str, event_id: int):
+    def update_last_event_id(self, subscriber_id: str, event_id: int) -> None:
         """Update the last event ID received by a durable subscriber (for replay)."""
         try:
             from db_connection_manager import DbConnectionManager

package/src/tree/builder.py

@@ -22,70 +22,72 @@ class TreeBuilderMixin:
         5. Update aggregated counts
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Clear existing tree (keep root)
-        cursor.execute('DELETE FROM memory_tree WHERE node_type != ?', ('root',))
-
-        # Step 1: Create project nodes
-        cursor.execute('''
-            SELECT DISTINCT project_path, project_name
-            FROM memories
-            WHERE project_path IS NOT NULL
-            ORDER BY project_path
-        ''')
-        projects = cursor.fetchall()
-
-        project_map = {}  # project_path -> node_id
-
-        for project_path, project_name in projects:
-            name = project_name or project_path.split('/')[-1]
-            node_id = self.add_node('project', name, self.root_id, description=project_path)
-            project_map[project_path] = node_id
-
-        # Step 2: Create category nodes within projects
-        cursor.execute('''
-            SELECT DISTINCT project_path, category
-            FROM memories
-            WHERE project_path IS NOT NULL AND category IS NOT NULL
-            ORDER BY project_path, category
-        ''')
-        categories = cursor.fetchall()
-
-        category_map = {}  # (project_path, category) -> node_id
-
-        for project_path, category in categories:
-            parent_id = project_map.get(project_path)
-            if parent_id:
-                node_id = self.add_node('category', category, parent_id)
-                category_map[(project_path, category)] = node_id
-
-        # Step 3: Link memories as leaf nodes
-        cursor.execute('''
-            SELECT id, content, summary, project_path, category, importance, created_at
-            FROM memories
-            ORDER BY created_at DESC
-        ''')
-        memories = cursor.fetchall()
-
-        for mem_id, content, summary, project_path, category, importance, created_at in memories:
-            # Determine parent node
-            if project_path and category and (project_path, category) in category_map:
-                parent_id = category_map[(project_path, category)]
-            elif project_path and project_path in project_map:
-                parent_id = project_map[project_path]
-            else:
-                parent_id = self.root_id
-
-            # Create memory node
-            name = summary or content[:60].replace('\n', ' ')
-            self.add_node('memory', name, parent_id, memory_id=mem_id, description=content[:200])
-
-        # Step 4: Update aggregated counts
-        self._update_all_counts()
-
-        conn.commit()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Clear existing tree (keep root)
+            cursor.execute('DELETE FROM memory_tree WHERE node_type != ?', ('root',))
+
+            # Step 1: Create project nodes
+            cursor.execute('''
+                SELECT DISTINCT project_path, project_name
+                FROM memories
+                WHERE project_path IS NOT NULL
+                ORDER BY project_path
+            ''')
+            projects = cursor.fetchall()
+
+            project_map = {}  # project_path -> node_id
+
+            for project_path, project_name in projects:
+                name = project_name or project_path.split('/')[-1]
+                node_id = self.add_node('project', name, self.root_id, description=project_path)
+                project_map[project_path] = node_id
+
+            # Step 2: Create category nodes within projects
+            cursor.execute('''
+                SELECT DISTINCT project_path, category
+                FROM memories
+                WHERE project_path IS NOT NULL AND category IS NOT NULL
+                ORDER BY project_path, category
+            ''')
+            categories = cursor.fetchall()
+
+            category_map = {}  # (project_path, category) -> node_id
+
+            for project_path, category in categories:
+                parent_id = project_map.get(project_path)
+                if parent_id:
+                    node_id = self.add_node('category', category, parent_id)
+                    category_map[(project_path, category)] = node_id
+
+            # Step 3: Link memories as leaf nodes
+            cursor.execute('''
+                SELECT id, content, summary, project_path, category, importance, created_at
+                FROM memories
+                ORDER BY created_at DESC
+            ''')
+            memories = cursor.fetchall()
+
+            for mem_id, content, summary, project_path, category, importance, created_at in memories:
+                # Determine parent node
+                if project_path and category and (project_path, category) in category_map:
+                    parent_id = category_map[(project_path, category)]
+                elif project_path and project_path in project_map:
+                    parent_id = project_map[project_path]
+                else:
+                    parent_id = self.root_id
+
+                # Create memory node
+                name = summary or content[:60].replace('\n', ' ')
+                self.add_node('memory', name, parent_id, memory_id=mem_id, description=content[:200])
+
+            # Step 4: Update aggregated counts
+            self._update_all_counts()
+
+            conn.commit()
+        finally:
+            conn.close()
 
 
 def run_cli():

package/src/tree/nodes.py

@@ -35,46 +35,48 @@ class TreeNodesMixin:
             New node ID
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Get parent path and depth
-        cursor.execute('SELECT tree_path, depth FROM memory_tree WHERE id = ?', (parent_id,))
-        result = cursor.fetchone()
-
-        if not result:
-            raise ValueError(f"Parent node {parent_id} not found")
-
-        parent_path, parent_depth = result
-
-        # Calculate new node position
-        depth = parent_depth + 1
-
-        cursor.execute('''
-            INSERT INTO memory_tree (
-                node_type, name, description,
-                parent_id, tree_path, depth,
-                memory_id, last_updated
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        ''', (
-            node_type,
-            name,
-            description,
-            parent_id,
-            '',  # Placeholder, updated below
-            depth,
-            memory_id,
-            datetime.now().isoformat()
-        ))
-
-        node_id = cursor.lastrowid
-
-        # Update tree_path with actual node_id
-        tree_path = f"{parent_path}.{node_id}"
-        cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (tree_path, node_id))
-
-        conn.commit()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Get parent path and depth
+            cursor.execute('SELECT tree_path, depth FROM memory_tree WHERE id = ?', (parent_id,))
+            result = cursor.fetchone()
+
+            if not result:
+                raise ValueError(f"Parent node {parent_id} not found")
+
+            parent_path, parent_depth = result
+
+            # Calculate new node position
+            depth = parent_depth + 1
+
+            cursor.execute('''
+                INSERT INTO memory_tree (
+                    node_type, name, description,
+                    parent_id, tree_path, depth,
+                    memory_id, last_updated
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                node_type,
+                name,
+                description,
+                parent_id,
+                '',  # Placeholder, updated below
+                depth,
+                memory_id,
+                datetime.now().isoformat()
+            ))
+
+            node_id = cursor.lastrowid
+
+            # Update tree_path with actual node_id
+            tree_path = f"{parent_path}.{node_id}"
+            cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (tree_path, node_id))
+
+            conn.commit()
+        finally:
+            conn.close()
 
         return node_id
 
@@ -92,25 +94,26 @@ class TreeNodesMixin:
             raise ValueError("Cannot delete root node")
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Get tree_path
-        cursor.execute('SELECT tree_path, parent_id FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
+            # Get tree_path
+            cursor.execute('SELECT tree_path, parent_id FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
 
-        if not result:
-            conn.close()
-            return False
+            if not result:
+                return False
 
-        tree_path, parent_id = result
+            tree_path, parent_id = result
 
-        # Delete node and all descendants (CASCADE handles children)
-        cursor.execute('DELETE FROM memory_tree WHERE id = ? OR tree_path LIKE ?',
-                      (node_id, f"{tree_path}.%"))
+            # Delete node and all descendants (CASCADE handles children)
+            cursor.execute('DELETE FROM memory_tree WHERE id = ? OR tree_path LIKE ?',
+                          (node_id, f"{tree_path}.%"))
 
-        deleted = cursor.rowcount > 0
-        conn.commit()
-        conn.close()
+            deleted = cursor.rowcount > 0
+            conn.commit()
+        finally:
+            conn.close()
 
         # Update parent counts
         if deleted and parent_id:
@@ -127,56 +130,59 @@ class TreeNodesMixin:
             node_id: Node ID to update
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Get all descendant memory nodes
-        cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
-
-        if not result:
+        try:
+            cursor = conn.cursor()
+
+            # Get all descendant memory nodes
+            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
+
+            if not result:
+                return
+
+            tree_path = result[0]
+
+            # Count memories in subtree
+            cursor.execute('''
+                SELECT COUNT(*), COALESCE(SUM(LENGTH(m.content)), 0)
+                FROM memory_tree t
+                LEFT JOIN memories m ON t.memory_id = m.id
+                WHERE t.tree_path LIKE ? AND t.memory_id IS NOT NULL
+            ''', (f"{tree_path}%",))
+
+            memory_count, total_size = cursor.fetchone()
+
+            # Update node
+            cursor.execute('''
+                UPDATE memory_tree
+                SET memory_count = ?, total_size = ?, last_updated = ?
+                WHERE id = ?
+            ''', (memory_count, total_size, datetime.now().isoformat(), node_id))
+
+            # Update all ancestors
+            path_ids = [int(x) for x in tree_path.split('.')]
+            for ancestor_id in path_ids[:-1]:  # Exclude current node
+                self.update_counts(ancestor_id)
+
+            conn.commit()
+        finally:
             conn.close()
-            return
-
-        tree_path = result[0]
-
-        # Count memories in subtree
-        cursor.execute('''
-            SELECT COUNT(*), COALESCE(SUM(LENGTH(m.content)), 0)
-            FROM memory_tree t
-            LEFT JOIN memories m ON t.memory_id = m.id
-            WHERE t.tree_path LIKE ? AND t.memory_id IS NOT NULL
-        ''', (f"{tree_path}%",))
-
-        memory_count, total_size = cursor.fetchone()
-
-        # Update node
-        cursor.execute('''
-            UPDATE memory_tree
-            SET memory_count = ?, total_size = ?, last_updated = ?
-            WHERE id = ?
-        ''', (memory_count, total_size, datetime.now().isoformat(), node_id))
-
-        # Update all ancestors
-        path_ids = [int(x) for x in tree_path.split('.')]
-        for ancestor_id in path_ids[:-1]:  # Exclude current node
-            self.update_counts(ancestor_id)
-
-        conn.commit()
-        conn.close()
 
     def _update_all_counts(self):
         """Update counts for all nodes (used after build_tree)."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Get all nodes in reverse depth order (leaves first)
-        cursor.execute('''
-            SELECT id FROM memory_tree
-            ORDER BY depth DESC
-        ''')
+            # Get all nodes in reverse depth order (leaves first)
+            cursor.execute('''
+                SELECT id FROM memory_tree
+                ORDER BY depth DESC
+            ''')
 
-        node_ids = [row[0] for row in cursor.fetchall()]
-        conn.close()
+            node_ids = [row[0] for row in cursor.fetchall()]
+        finally:
+            conn.close()
 
         # Update each node (will cascade to parents)
         processed = set()