superlocalmemory 2.8.2 → 2.8.5

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()

package/src/tree/queries.py

@@ -28,60 +28,61 @@ class TreeQueriesMixin:
             Nested dictionary representing tree structure
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Build query
-        if project_name:
-            # Find project node
-            cursor.execute('''
-                SELECT id, tree_path FROM memory_tree
-                WHERE node_type = 'project' AND name = ?
-            ''', (project_name,))
-            result = cursor.fetchone()
-
-            if not result:
-                conn.close()
-                return {'error': f"Project '{project_name}' not found"}
-
-            project_id, project_path = result
-
-            # Get subtree
-            if max_depth is not None:
+            # Build query
+            if project_name:
+                # Find project node
                 cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE (id = ? OR tree_path LIKE ?) AND depth <= ?
-                    ORDER BY tree_path
-                ''', (project_id, f"{project_path}.%", max_depth))
+                    SELECT id, tree_path FROM memory_tree
+                    WHERE node_type = 'project' AND name = ?
+                ''', (project_name,))
+                result = cursor.fetchone()
+
+                if not result:
+                    return {'error': f"Project '{project_name}' not found"}
+
+                project_id, project_path = result
+
+                # Get subtree
+                if max_depth is not None:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE (id = ? OR tree_path LIKE ?) AND depth <= ?
+                        ORDER BY tree_path
+                    ''', (project_id, f"{project_path}.%", max_depth))
+                else:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE id = ? OR tree_path LIKE ?
+                        ORDER BY tree_path
+                    ''', (project_id, f"{project_path}.%"))
             else:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE id = ? OR tree_path LIKE ?
-                    ORDER BY tree_path
-                ''', (project_id, f"{project_path}.%"))
-        else:
-            # Get entire tree
-            if max_depth is not None:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    WHERE depth <= ?
-                    ORDER BY tree_path
-                ''', (max_depth,))
-            else:
-                cursor.execute('''
-                    SELECT id, node_type, name, description, parent_id, tree_path,
-                           depth, memory_count, total_size, last_updated, memory_id
-                    FROM memory_tree
-                    ORDER BY tree_path
-                ''')
-
-        rows = cursor.fetchall()
-        conn.close()
+                # Get entire tree
+                if max_depth is not None:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        WHERE depth <= ?
+                        ORDER BY tree_path
+                    ''', (max_depth,))
+                else:
+                    cursor.execute('''
+                        SELECT id, node_type, name, description, parent_id, tree_path,
+                               depth, memory_count, total_size, last_updated, memory_id
+                        FROM memory_tree
+                        ORDER BY tree_path
+                    ''')
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         if not rows:
             return {'error': 'No tree nodes found'}
@@ -125,44 +126,45 @@ class TreeQueriesMixin:
             List of descendant nodes
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
+
+            # Get node's tree_path
+            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
+
+            if not result:
+                return []
 
-        # Get node's tree_path
-        cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
+            tree_path = result[0]
 
-        if not result:
+            # Get all descendants
+            cursor.execute('''
+                SELECT id, node_type, name, description, parent_id, tree_path,
+                       depth, memory_count, total_size, last_updated, memory_id
+                FROM memory_tree
+                WHERE tree_path LIKE ?
+                ORDER BY tree_path
+            ''', (f"{tree_path}.%",))
+
+            results = []
+            for row in cursor.fetchall():
+                results.append({
+                    'id': row[0],
+                    'type': row[1],
+                    'name': row[2],
+                    'description': row[3],
+                    'parent_id': row[4],
+                    'tree_path': row[5],
+                    'depth': row[6],
+                    'memory_count': row[7],
+                    'total_size': row[8],
+                    'last_updated': row[9],
+                    'memory_id': row[10]
+                })
+        finally:
             conn.close()
-            return []
-
-        tree_path = result[0]
-
-        # Get all descendants
-        cursor.execute('''
-            SELECT id, node_type, name, description, parent_id, tree_path,
-                   depth, memory_count, total_size, last_updated, memory_id
-            FROM memory_tree
-            WHERE tree_path LIKE ?
-            ORDER BY tree_path
-        ''', (f"{tree_path}.%",))
-
-        results = []
-        for row in cursor.fetchall():
-            results.append({
-                'id': row[0],
-                'type': row[1],
-                'name': row[2],
-                'description': row[3],
-                'parent_id': row[4],
-                'tree_path': row[5],
-                'depth': row[6],
-                'memory_count': row[7],
-                'total_size': row[8],
-                'last_updated': row[9],
-                'memory_id': row[10]
-            })
 
-        conn.close()
         return results
 
     def get_path_to_root(self, node_id: int) -> List[Dict[str, Any]]:
@@ -176,72 +178,75 @@ class TreeQueriesMixin:
             List of nodes from root to target node
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Get node's tree_path
-        cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
-        result = cursor.fetchone()
+            # Get node's tree_path
+            cursor.execute('SELECT tree_path FROM memory_tree WHERE id = ?', (node_id,))
+            result = cursor.fetchone()
 
-        if not result:
+            if not result:
+                return []
+
+            tree_path = result[0]
+
+            # Parse path to get all ancestor IDs
+            path_ids = [int(x) for x in tree_path.split('.')]
+
+            # Get all ancestor nodes
+            placeholders = ','.join('?' * len(path_ids))
+            cursor.execute(f'''
+                SELECT id, node_type, name, description, parent_id, tree_path,
+                       depth, memory_count, total_size, last_updated, memory_id
+                FROM memory_tree
+                WHERE id IN ({placeholders})
+                ORDER BY depth
+            ''', path_ids)
+
+            results = []
+            for row in cursor.fetchall():
+                results.append({
+                    'id': row[0],
+                    'type': row[1],
+                    'name': row[2],
+                    'description': row[3],
+                    'parent_id': row[4],
+                    'tree_path': row[5],
+                    'depth': row[6],
+                    'memory_count': row[7],
+                    'total_size': row[8],
+                    'last_updated': row[9],
+                    'memory_id': row[10]
+                })
+        finally:
             conn.close()
-            return []
-
-        tree_path = result[0]
-
-        # Parse path to get all ancestor IDs
-        path_ids = [int(x) for x in tree_path.split('.')]
-
-        # Get all ancestor nodes
-        placeholders = ','.join('?' * len(path_ids))
-        cursor.execute(f'''
-            SELECT id, node_type, name, description, parent_id, tree_path,
-                   depth, memory_count, total_size, last_updated, memory_id
-            FROM memory_tree
-            WHERE id IN ({placeholders})
-            ORDER BY depth
-        ''', path_ids)
-
-        results = []
-        for row in cursor.fetchall():
-            results.append({
-                'id': row[0],
-                'type': row[1],
-                'name': row[2],
-                'description': row[3],
-                'parent_id': row[4],
-                'tree_path': row[5],
-                'depth': row[6],
-                'memory_count': row[7],
-                'total_size': row[8],
-                'last_updated': row[9],
-                'memory_id': row[10]
-            })
 
-        conn.close()
         return results
 
     def get_stats(self) -> Dict[str, Any]:
         """Get tree statistics."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        cursor.execute('SELECT COUNT(*) FROM memory_tree')
-        total_nodes = cursor.fetchone()[0]
+            cursor.execute('SELECT COUNT(*) FROM memory_tree')
+            total_nodes = cursor.fetchone()[0]
 
-        cursor.execute('SELECT node_type, COUNT(*) FROM memory_tree GROUP BY node_type')
-        by_type = dict(cursor.fetchall())
+            cursor.execute('SELECT node_type, COUNT(*) FROM memory_tree GROUP BY node_type')
+            by_type = dict(cursor.fetchall())
 
-        cursor.execute('SELECT MAX(depth) FROM memory_tree')
-        max_depth = cursor.fetchone()[0] or 0
+            cursor.execute('SELECT MAX(depth) FROM memory_tree')
+            max_depth = cursor.fetchone()[0] or 0
 
-        cursor.execute('''
-            SELECT SUM(memory_count), SUM(total_size)
-            FROM memory_tree
-            WHERE node_type = 'root'
-        ''')
-        total_memories, total_size = cursor.fetchone()
+            cursor.execute('''
+                SELECT SUM(memory_count), SUM(total_size)
+                FROM memory_tree
+                WHERE node_type = 'root'
+            ''')
+            total_memories, total_size = cursor.fetchone()
 
-        conn.close()
+        finally:
+            conn.close()
 
         return {
             'total_nodes': total_nodes,

package/src/tree/schema.py

@@ -20,57 +20,61 @@ class TreeSchemaMixin:
     def _init_db(self):
         """Initialize memory_tree table."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        cursor.execute('''
-            CREATE TABLE IF NOT EXISTS memory_tree (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                node_type TEXT NOT NULL,
-                name TEXT NOT NULL,
-                description TEXT,
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS memory_tree (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    node_type TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    description TEXT,
 
-                parent_id INTEGER,
-                tree_path TEXT NOT NULL,
-                depth INTEGER DEFAULT 0,
+                    parent_id INTEGER,
+                    tree_path TEXT NOT NULL,
+                    depth INTEGER DEFAULT 0,
 
-                memory_count INTEGER DEFAULT 0,
-                total_size INTEGER DEFAULT 0,
-                last_updated TIMESTAMP,
+                    memory_count INTEGER DEFAULT 0,
+                    total_size INTEGER DEFAULT 0,
+                    last_updated TIMESTAMP,
 
-                memory_id INTEGER,
+                    memory_id INTEGER,
 
-                FOREIGN KEY (parent_id) REFERENCES memory_tree(id) ON DELETE CASCADE,
-                FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-            )
-        ''')
+                    FOREIGN KEY (parent_id) REFERENCES memory_tree(id) ON DELETE CASCADE,
+                    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
+                )
+            ''')
 
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_tree_path_layer2 ON memory_tree(tree_path)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_node_type ON memory_tree(node_type)')
-        cursor.execute('CREATE INDEX IF NOT EXISTS idx_parent_id_tree ON memory_tree(parent_id)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_tree_path_layer2 ON memory_tree(tree_path)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_node_type ON memory_tree(node_type)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_parent_id_tree ON memory_tree(parent_id)')
 
-        conn.commit()
-        conn.close()
+            conn.commit()
+        finally:
+            conn.close()
 
     def _ensure_root(self) -> int:
         """Ensure root node exists and return its ID."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        cursor.execute('SELECT id FROM memory_tree WHERE node_type = ? AND parent_id IS NULL', ('root',))
-        result = cursor.fetchone()
-
-        if result:
-            root_id = result[0]
-        else:
-            cursor.execute('''
-                INSERT INTO memory_tree (node_type, name, tree_path, depth, last_updated)
-                VALUES (?, ?, ?, ?, ?)
-            ''', ('root', 'Root', '1', 0, datetime.now().isoformat()))
-            root_id = cursor.lastrowid
-
-            # Update tree_path with actual ID
-            cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (str(root_id), root_id))
-            conn.commit()
-
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            cursor.execute('SELECT id FROM memory_tree WHERE node_type = ? AND parent_id IS NULL', ('root',))
+            result = cursor.fetchone()
+
+            if result:
+                root_id = result[0]
+            else:
+                cursor.execute('''
+                    INSERT INTO memory_tree (node_type, name, tree_path, depth, last_updated)
+                    VALUES (?, ?, ?, ?, ?)
+                ''', ('root', 'Root', '1', 0, datetime.now().isoformat()))
+                root_id = cursor.lastrowid
+
+                # Update tree_path with actual ID
+                cursor.execute('UPDATE memory_tree SET tree_path = ? WHERE id = ?', (str(root_id), root_id))
+                conn.commit()
+
+        finally:
+            conn.close()
         return root_id