superlocalmemory 2.8.2 → 2.8.5

package/src/patterns/analyzers.py

@@ -41,59 +41,61 @@ class FrequencyAnalyzer:
         patterns = {}
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        for category, keywords in self.tech_categories.items():
-            keyword_counts = Counter()
-            evidence_memories = {}  # {keyword: [memory_ids]}
-
-            for memory_id in memory_ids:
-                cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
-                row = cursor.fetchone()
-
-                if not row:
-                    continue
-
-                content = row[0].lower()
-
-                for keyword in keywords:
-                    # Count occurrences with word boundaries
-                    pattern = r'\b' + re.escape(keyword.replace('.', r'\.')) + r'\b'
-                    matches = re.findall(pattern, content, re.IGNORECASE)
-                    count = len(matches)
-
-                    if count > 0:
-                        keyword_counts[keyword] += count
-
-                        if keyword not in evidence_memories:
-                            evidence_memories[keyword] = []
-                        evidence_memories[keyword].append(memory_id)
-
-            # Determine preference (most mentioned)
-            if keyword_counts:
-                top_keyword = keyword_counts.most_common(1)[0][0]
-                total_mentions = sum(keyword_counts.values())
-                top_count = keyword_counts[top_keyword]
-
-                # Calculate confidence (% of mentions)
-                confidence = top_count / total_mentions if total_mentions > 0 else 0
-
-                # Only create pattern if confidence > 0.6 and at least 3 mentions
-                if confidence > 0.6 and top_count >= 3:
-                    value = self._format_preference(top_keyword, keyword_counts)
-                    evidence_list = list(set(evidence_memories.get(top_keyword, [])))
-
-                    patterns[category] = {
-                        'pattern_type': 'preference',
-                        'key': category,
-                        'value': value,
-                        'confidence': round(confidence, 2),
-                        'evidence_count': len(evidence_list),
-                        'memory_ids': evidence_list,
-                        'category': self._categorize_pattern(category)
-                    }
-
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            for category, keywords in self.tech_categories.items():
+                keyword_counts = Counter()
+                evidence_memories = {}  # {keyword: [memory_ids]}
+
+                for memory_id in memory_ids:
+                    cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
+                    row = cursor.fetchone()
+
+                    if not row:
+                        continue
+
+                    content = row[0].lower()
+
+                    for keyword in keywords:
+                        # Count occurrences with word boundaries
+                        pattern = r'\b' + re.escape(keyword.replace('.', r'\.')) + r'\b'
+                        matches = re.findall(pattern, content, re.IGNORECASE)
+                        count = len(matches)
+
+                        if count > 0:
+                            keyword_counts[keyword] += count
+
+                            if keyword not in evidence_memories:
+                                evidence_memories[keyword] = []
+                            evidence_memories[keyword].append(memory_id)
+
+                # Determine preference (most mentioned)
+                if keyword_counts:
+                    top_keyword = keyword_counts.most_common(1)[0][0]
+                    total_mentions = sum(keyword_counts.values())
+                    top_count = keyword_counts[top_keyword]
+
+                    # Calculate confidence (% of mentions)
+                    confidence = top_count / total_mentions if total_mentions > 0 else 0
+
+                    # Only create pattern if confidence > 0.6 and at least 3 mentions
+                    if confidence > 0.6 and top_count >= 3:
+                        value = self._format_preference(top_keyword, keyword_counts)
+                        evidence_list = list(set(evidence_memories.get(top_keyword, [])))
+
+                        patterns[category] = {
+                            'pattern_type': 'preference',
+                            'key': category,
+                            'value': value,
+                            'confidence': round(confidence, 2),
+                            'evidence_count': len(evidence_list),
+                            'memory_ids': evidence_list,
+                            'category': self._categorize_pattern(category)
+                        }
+
+        finally:
+            conn.close()
         return patterns
 
     def _format_preference(self, top_keyword: str, all_counts: Counter) -> str:
@@ -171,53 +173,55 @@ class ContextAnalyzer:
         patterns = {}
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        for pattern_key, indicators in self.style_indicators.items():
-            indicator_counts = Counter()
-            evidence_memories = {}  # {style_type: [memory_ids]}
-
-            for memory_id in memory_ids:
-                cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
-                row = cursor.fetchone()
-
-                if not row:
-                    continue
-
-                content = row[0].lower()
-
-                for style_type, keywords in indicators.items():
-                    for keyword in keywords:
-                        if keyword in content:
-                            indicator_counts[style_type] += 1
-
-                            if style_type not in evidence_memories:
-                                evidence_memories[style_type] = []
-                            evidence_memories[style_type].append(memory_id)
-
-            # Determine dominant style
-            if indicator_counts:
-                top_style = indicator_counts.most_common(1)[0][0]
-                total = sum(indicator_counts.values())
-                top_count = indicator_counts[top_style]
-                confidence = top_count / total if total > 0 else 0
-
-                # Only create pattern if confidence > 0.65 and at least 3 mentions
-                if confidence > 0.65 and top_count >= 3:
-                    value = self._format_style_value(pattern_key, top_style, indicator_counts)
-                    evidence_list = list(set(evidence_memories.get(top_style, [])))
-
-                    patterns[pattern_key] = {
-                        'pattern_type': 'style',
-                        'key': pattern_key,
-                        'value': value,
-                        'confidence': round(confidence, 2),
-                        'evidence_count': len(evidence_list),
-                        'memory_ids': evidence_list,
-                        'category': 'general'
-                    }
-
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            for pattern_key, indicators in self.style_indicators.items():
+                indicator_counts = Counter()
+                evidence_memories = {}  # {style_type: [memory_ids]}
+
+                for memory_id in memory_ids:
+                    cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
+                    row = cursor.fetchone()
+
+                    if not row:
+                        continue
+
+                    content = row[0].lower()
+
+                    for style_type, keywords in indicators.items():
+                        for keyword in keywords:
+                            if keyword in content:
+                                indicator_counts[style_type] += 1
+
+                                if style_type not in evidence_memories:
+                                    evidence_memories[style_type] = []
+                                evidence_memories[style_type].append(memory_id)
+
+                # Determine dominant style
+                if indicator_counts:
+                    top_style = indicator_counts.most_common(1)[0][0]
+                    total = sum(indicator_counts.values())
+                    top_count = indicator_counts[top_style]
+                    confidence = top_count / total if total > 0 else 0
+
+                    # Only create pattern if confidence > 0.65 and at least 3 mentions
+                    if confidence > 0.65 and top_count >= 3:
+                        value = self._format_style_value(pattern_key, top_style, indicator_counts)
+                        evidence_list = list(set(evidence_memories.get(top_style, [])))
+
+                        patterns[pattern_key] = {
+                            'pattern_type': 'style',
+                            'key': pattern_key,
+                            'value': value,
+                            'confidence': round(confidence, 2),
+                            'evidence_count': len(evidence_list),
+                            'memory_ids': evidence_list,
+                            'category': 'general'
+                        }
+
+        finally:
+            conn.close()
         return patterns
 
     def _format_style_value(self, pattern_key: str, top_style: str, all_counts: Counter) -> str:

package/src/patterns/learner.py

@@ -66,12 +66,14 @@ class PatternLearner:
 
         # Get memory IDs for active profile only
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute('SELECT id FROM memories WHERE profile = ? ORDER BY created_at',
-                       (active_profile,))
-        all_memory_ids = [row[0] for row in cursor.fetchall()]
-        total_memories = len(all_memory_ids)
-        conn.close()
+        try:
+            cursor = conn.cursor()
+            cursor.execute('SELECT id FROM memories WHERE profile = ? ORDER BY created_at',
+                           (active_profile,))
+            all_memory_ids = [row[0] for row in cursor.fetchall()]
+            total_memories = len(all_memory_ids)
+        finally:
+            conn.close()
 
         if total_memories == 0:
             print(f"No memories found for profile '{active_profile}'. Add memories first.")
@@ -142,16 +144,18 @@ class PatternLearner:
         """Incremental update when new memory is added."""
         active_profile = self._get_active_profile()
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        cursor.execute('SELECT COUNT(*) FROM memories WHERE profile = ?',
-                       (active_profile,))
-        total = cursor.fetchone()[0]
-        conn.close()
+        try:
+            cursor = conn.cursor()
+            cursor.execute('SELECT COUNT(*) FROM memories WHERE profile = ?',
+                           (active_profile,))
+            total = cursor.fetchone()[0]
+        finally:
+            conn.close()
 
         # Only do incremental updates if we have many memories (>50)
         if total > 50:
-            # TODO: Implement true incremental update
-            print(f"New memory #{memory_id} added. Run weekly_pattern_update() to update patterns.")
+            # Deferred to batch update for efficiency (see weekly_pattern_update)
+            pass
         else:
             # For small memory counts, just do full update
             self.weekly_pattern_update()

package/src/patterns/scoring.py

@@ -83,18 +83,20 @@ class ConfidenceScorer:
     def _calculate_recency_bonus(self, memory_ids: List[int]) -> float:
         """Give bonus to patterns with recent evidence."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
+        try:
+            cursor = conn.cursor()
 
-        # Get timestamps
-        placeholders = ','.join('?' * len(memory_ids))
-        cursor.execute(f'''
-            SELECT created_at FROM memories
-            WHERE id IN ({placeholders})
-            ORDER BY created_at DESC
-        ''', memory_ids)
+            # Get timestamps
+            placeholders = ','.join('?' * len(memory_ids))
+            cursor.execute(f'''
+                SELECT created_at FROM memories
+                WHERE id IN ({placeholders})
+                ORDER BY created_at DESC
+            ''', memory_ids)
 
-        timestamps = cursor.fetchall()
-        conn.close()
+            timestamps = cursor.fetchall()
+        finally:
+            conn.close()
 
         if not timestamps:
             return 1.0
@@ -124,17 +126,19 @@ class ConfidenceScorer:
             return 0.8  # Penalize low sample size
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        placeholders = ','.join('?' * len(memory_ids))
-        cursor.execute(f'''
-            SELECT created_at FROM memories
-            WHERE id IN ({placeholders})
-            ORDER BY created_at
-        ''', memory_ids)
-
-        timestamps = [row[0] for row in cursor.fetchall()]
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            placeholders = ','.join('?' * len(memory_ids))
+            cursor.execute(f'''
+                SELECT created_at FROM memories
+                WHERE id IN ({placeholders})
+                ORDER BY created_at
+            ''', memory_ids)
+
+            timestamps = [row[0] for row in cursor.fetchall()]
+        finally:
+            conn.close()
 
         if len(timestamps) < 2:
             return 0.8

package/src/patterns/store.py

@@ -181,43 +181,45 @@ class PatternStore:
                      profile: Optional[str] = None) -> List[Dict[str, Any]]:
         """Get patterns above confidence threshold, optionally filtered by profile."""
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Build query with optional filters
-        conditions = ['confidence >= ?']
-        params = [min_confidence]
-
-        if pattern_type:
-            conditions.append('pattern_type = ?')
-            params.append(pattern_type)
-
-        if profile:
-            conditions.append('profile = ?')
-            params.append(profile)
-
-        where_clause = ' AND '.join(conditions)
-        cursor.execute(f'''
-            SELECT id, pattern_type, key, value, confidence, evidence_count,
-                   updated_at, created_at, category
-            FROM identity_patterns
-            WHERE {where_clause}
-            ORDER BY confidence DESC, evidence_count DESC
-        ''', params)
-
-        patterns = []
-        for row in cursor.fetchall():
-            patterns.append({
-                'id': row[0],
-                'pattern_type': row[1],
-                'key': row[2],
-                'value': row[3],
-                'confidence': row[4],
-                'evidence_count': row[5],
-                'frequency': row[5],
-                'last_seen': row[6],
-                'created_at': row[7],
-                'category': row[8]
-            })
+        try:
+            cursor = conn.cursor()
+
+            # Build query with optional filters
+            conditions = ['confidence >= ?']
+            params = [min_confidence]
+
+            if pattern_type:
+                conditions.append('pattern_type = ?')
+                params.append(pattern_type)
+
+            if profile:
+                conditions.append('profile = ?')
+                params.append(profile)
+
+            where_clause = ' AND '.join(conditions)
+            cursor.execute(f'''
+                SELECT id, pattern_type, key, value, confidence, evidence_count,
+                       updated_at, created_at, category
+                FROM identity_patterns
+                WHERE {where_clause}
+                ORDER BY confidence DESC, evidence_count DESC
+            ''', params)
+
+            patterns = []
+            for row in cursor.fetchall():
+                patterns.append({
+                    'id': row[0],
+                    'pattern_type': row[1],
+                    'key': row[2],
+                    'value': row[3],
+                    'confidence': row[4],
+                    'evidence_count': row[5],
+                    'frequency': row[5],
+                    'last_seen': row[6],
+                    'created_at': row[7],
+                    'category': row[8]
+                })
 
-        conn.close()
+        finally:
+            conn.close()
         return patterns

package/src/patterns/terminology.py

@@ -36,57 +36,59 @@ class TerminologyLearner:
         patterns = {}
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        for term in self.ambiguous_terms:
-            contexts = []
-
-            # Find all contexts where term appears
-            for memory_id in memory_ids:
-                cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
-                row = cursor.fetchone()
-
-                if not row:
-                    continue
-
-                content = row[0]
-
-                # Find term in content (case-insensitive)
-                pattern = r'\b' + re.escape(term) + r'\b'
-                for match in re.finditer(pattern, content, re.IGNORECASE):
-                    term_idx = match.start()
-
-                    # Extract 100-char window around term
-                    start = max(0, term_idx - 100)
-                    end = min(len(content), term_idx + len(term) + 100)
-                    context_window = content[start:end]
-
-                    contexts.append({
-                        'memory_id': memory_id,
-                        'context': context_window
-                    })
-
-            # Analyze contexts to extract meaning (need at least 3 examples)
-            if len(contexts) >= 3:
-                definition = self._extract_definition(term, contexts)
-
-                if definition:
-                    evidence_list = list(set([ctx['memory_id'] for ctx in contexts]))
-
-                    # Confidence increases with more examples, capped at 0.95
-                    confidence = min(0.95, 0.6 + (len(contexts) * 0.05))
-
-                    patterns[term] = {
-                        'pattern_type': 'terminology',
-                        'key': term,
-                        'value': definition,
-                        'confidence': round(confidence, 2),
-                        'evidence_count': len(evidence_list),
-                        'memory_ids': evidence_list,
-                        'category': 'general'
-                    }
-
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            for term in self.ambiguous_terms:
+                contexts = []
+
+                # Find all contexts where term appears
+                for memory_id in memory_ids:
+                    cursor.execute('SELECT content FROM memories WHERE id = ?', (memory_id,))
+                    row = cursor.fetchone()
+
+                    if not row:
+                        continue
+
+                    content = row[0]
+
+                    # Find term in content (case-insensitive)
+                    pattern = r'\b' + re.escape(term) + r'\b'
+                    for match in re.finditer(pattern, content, re.IGNORECASE):
+                        term_idx = match.start()
+
+                        # Extract 100-char window around term
+                        start = max(0, term_idx - 100)
+                        end = min(len(content), term_idx + len(term) + 100)
+                        context_window = content[start:end]
+
+                        contexts.append({
+                            'memory_id': memory_id,
+                            'context': context_window
+                        })
+
+                # Analyze contexts to extract meaning (need at least 3 examples)
+                if len(contexts) >= 3:
+                    definition = self._extract_definition(term, contexts)
+
+                    if definition:
+                        evidence_list = list(set([ctx['memory_id'] for ctx in contexts]))
+
+                        # Confidence increases with more examples, capped at 0.95
+                        confidence = min(0.95, 0.6 + (len(contexts) * 0.05))
+
+                        patterns[term] = {
+                            'pattern_type': 'terminology',
+                            'key': term,
+                            'value': definition,
+                            'confidence': round(confidence, 2),
+                            'evidence_count': len(evidence_list),
+                            'memory_ids': evidence_list,
+                            'category': 'general'
+                        }
+
+        finally:
+            conn.close()
         return patterns
 
     def _extract_definition(self, term: str, contexts: List[Dict]) -> Optional[str]:

package/src/provenance_tracker.py

@@ -53,7 +53,7 @@ class ProvenanceTracker:
             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:
@@ -154,7 +154,7 @@ class ProvenanceTracker:
         source_protocol: str = "cli",
         trust_score: float = 1.0,
         derived_from: Optional[int] = None,
-    ):
+    ) -> None:
         """
         Record provenance metadata for a memory.
 

package/src/qualixar_attribution.py

@@ -45,7 +45,7 @@ class QualixarSigner:
 
     Example::
 
-        signer = QualixarSigner("superlocalmemory", "2.8.1")
+        signer = QualixarSigner("superlocalmemory", "2.8.3")
         signed = signer.sign({"memories": [...]})
         assert QualixarSigner.verify(signed) is True
     """

package/src/search/engine.py

@@ -172,20 +172,22 @@ class HybridSearchEngine(IndexLoaderMixin, SearchMethodsMixin, FusionMixin):
         id_to_score = {mem_id: score for mem_id, score in raw_results}
 
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Fetch memories
-        placeholders = ','.join(['?'] * len(memory_ids))
-        cursor.execute(f'''
-            SELECT id, content, summary, project_path, project_name, tags,
-                   category, parent_id, tree_path, depth, memory_type,
-                   importance, created_at, cluster_id, last_accessed, access_count
-            FROM memories
-            WHERE id IN ({placeholders})
-        ''', memory_ids)
-
-        rows = cursor.fetchall()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Fetch memories
+            placeholders = ','.join(['?'] * len(memory_ids))
+            cursor.execute(f'''
+                SELECT id, content, summary, project_path, project_name, tags,
+                       category, parent_id, tree_path, depth, memory_type,
+                       importance, created_at, cluster_id, last_accessed, access_count
+                FROM memories
+                WHERE id IN ({placeholders})
+            ''', memory_ids)
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         # Build result dictionaries
         results = []

package/src/search/index_loader.py

@@ -31,17 +31,19 @@ class IndexLoaderMixin:
         Load documents from database and build search indexes.
         """
         conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-
-        # Fetch all memories
-        cursor.execute('''
-            SELECT id, content, summary, tags
-            FROM memories
-            ORDER BY id
-        ''')
-
-        rows = cursor.fetchall()
-        conn.close()
+        try:
+            cursor = conn.cursor()
+
+            # Fetch all memories
+            cursor.execute('''
+                SELECT id, content, summary, tags
+                FROM memories
+                ORDER BY id
+            ''')
+
+            rows = cursor.fetchall()
+        finally:
+            conn.close()
 
         if not rows:
             return