superlocalmemory 2.8.6 → 3.0.1

package/src/patterns/analyzers.py

@@ -1,251 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Pattern Analyzers - Frequency and Context Analysis
-
-Technology preference detection via frequency counting,
-and coding style pattern detection from context.
-"""
-
-import sqlite3
-import re
-import logging
-from typing import Dict, List, Any
-from collections import Counter
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-
-class FrequencyAnalyzer:
-    """Analyzes technology and tool preferences via frequency counting."""
-
-    def __init__(self, db_path: Path):
-        self.db_path = db_path
-
-        # Predefined technology categories
-        self.tech_categories = {
-            'frontend_framework': ['react', 'nextjs', 'next.js', 'vue', 'angular', 'svelte', 'solid'],
-            'backend_framework': ['express', 'fastapi', 'django', 'flask', 'nestjs', 'spring', 'rails'],
-            'database': ['postgres', 'postgresql', 'mysql', 'mongodb', 'redis', 'dynamodb', 'sqlite'],
-            'state_management': ['redux', 'context', 'zustand', 'mobx', 'recoil', 'jotai'],
-            'styling': ['tailwind', 'css modules', 'styled-components', 'emotion', 'sass', 'less'],
-            'language': ['python', 'javascript', 'typescript', 'go', 'rust', 'java', 'c++'],
-            'deployment': ['docker', 'kubernetes', 'vercel', 'netlify', 'aws', 'gcp', 'azure'],
-            'testing': ['jest', 'pytest', 'vitest', 'mocha', 'cypress', 'playwright'],
-        }
-
-    def analyze_preferences(self, memory_ids: List[int]) -> Dict[str, Dict[str, Any]]:
-        """Analyze technology preferences across memories."""
-        patterns = {}
-
-        conn = sqlite3.connect(self.db_path)
-        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:
-        """Format preference value (e.g., 'Next.js over React')."""
-        # Normalize keyword for display
-        display_map = {
-            'nextjs': 'Next.js',
-            'next.js': 'Next.js',
-            'postgres': 'PostgreSQL',
-            'postgresql': 'PostgreSQL',
-            'fastapi': 'FastAPI',
-            'nestjs': 'NestJS',
-            'mongodb': 'MongoDB',
-            'redis': 'Redis',
-            'dynamodb': 'DynamoDB',
-            'tailwind': 'Tailwind CSS',
-        }
-
-        top_display = display_map.get(top_keyword.lower(), top_keyword.title())
-
-        if len(all_counts) > 1:
-            second = all_counts.most_common(2)[1]
-            second_keyword = second[0]
-            second_display = display_map.get(second_keyword.lower(), second_keyword.title())
-
-            # Only show comparison if second choice has significant mentions
-            if second[1] / all_counts[top_keyword] > 0.3:
-                return f"{top_display} over {second_display}"
-
-        return top_display
-
-    def _categorize_pattern(self, tech_category: str) -> str:
-        """Map tech category to high-level category."""
-        category_map = {
-            'frontend_framework': 'frontend',
-            'state_management': 'frontend',
-            'styling': 'frontend',
-            'backend_framework': 'backend',
-            'database': 'backend',
-            'language': 'general',
-            'deployment': 'devops',
-            'testing': 'general',
-        }
-        return category_map.get(tech_category, 'general')
-
-
-class ContextAnalyzer:
-    """Analyzes coding style patterns from context."""
-
-    def __init__(self, db_path: Path):
-        self.db_path = db_path
-
-        # Style pattern detection rules
-        self.style_indicators = {
-            'optimization_priority': {
-                'performance': ['optimize', 'faster', 'performance', 'speed', 'latency', 'efficient', 'cache'],
-                'readability': ['readable', 'clean', 'maintainable', 'clear', 'simple', 'understandable']
-            },
-            'error_handling': {
-                'explicit': ['error boundary', 'explicit', 'throw', 'handle error', 'try catch', 'error handling'],
-                'permissive': ['ignore', 'suppress', 'skip error', 'optional']
-            },
-            'testing_approach': {
-                'comprehensive': ['test coverage', 'unit test', 'integration test', 'e2e test', 'test suite'],
-                'minimal': ['manual test', 'skip test', 'no tests']
-            },
-            'code_organization': {
-                'modular': ['separate', 'module', 'component', 'split', 'refactor', 'extract'],
-                'monolithic': ['single file', 'one place', 'combined']
-            }
-        }
-
-    def analyze_style(self, memory_ids: List[int]) -> Dict[str, Dict[str, Any]]:
-        """Detect stylistic patterns from context."""
-        patterns = {}
-
-        conn = sqlite3.connect(self.db_path)
-        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:
-        """Format style value as comparison or preference."""
-        style_formats = {
-            'optimization_priority': {
-                'performance': 'Performance over readability',
-                'readability': 'Readability over performance'
-            },
-            'error_handling': {
-                'explicit': 'Explicit error boundaries',
-                'permissive': 'Permissive error handling'
-            },
-            'testing_approach': {
-                'comprehensive': 'Comprehensive testing',
-                'minimal': 'Minimal testing'
-            },
-            'code_organization': {
-                'modular': 'Modular organization',
-                'monolithic': 'Monolithic organization'
-            }
-        }
-
-        if pattern_key in style_formats and top_style in style_formats[pattern_key]:
-            return style_formats[pattern_key][top_style]
-
-        return top_style.replace('_', ' ').title()

package/src/patterns/learner.py

@@ -1,271 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Pattern Learner - Main orchestrator and CLI.
-
-Coordinates frequency analysis, context analysis, terminology learning,
-confidence scoring, and pattern storage into a unified learning pipeline.
-"""
-
-import sqlite3
-import json
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Any
-from collections import Counter
-
-from .analyzers import FrequencyAnalyzer, ContextAnalyzer
-from .terminology import TerminologyLearner
-from .scoring import ConfidenceScorer
-from .store import PatternStore
-
-logger = logging.getLogger(__name__)
-
-# Local NLP tools (no external APIs)
-try:
-    from sklearn.feature_extraction.text import TfidfVectorizer
-    from sklearn.metrics.pairwise import cosine_similarity
-    import numpy as np
-    SKLEARN_AVAILABLE = True
-except ImportError:
-    SKLEARN_AVAILABLE = False
-
-MEMORY_DIR = Path.home() / ".claude-memory"
-DB_PATH = MEMORY_DIR / "memory.db"
-
-
-class PatternLearner:
-    """Main pattern learning orchestrator."""
-
-    def __init__(self, db_path: Path = DB_PATH):
-        self.db_path = db_path
-        self.frequency_analyzer = FrequencyAnalyzer(db_path)
-        self.context_analyzer = ContextAnalyzer(db_path)
-        self.terminology_learner = TerminologyLearner(db_path)
-        self.confidence_scorer = ConfidenceScorer(db_path)
-        self.pattern_store = PatternStore(db_path)
-
-    def _get_active_profile(self) -> str:
-        """Get the currently active profile name from config."""
-        config_file = MEMORY_DIR / "profiles.json"
-        if config_file.exists():
-            try:
-                with open(config_file, 'r') as f:
-                    config = json.load(f)
-                return config.get('active_profile', 'default')
-            except (json.JSONDecodeError, IOError):
-                pass
-        return 'default'
-
-    def weekly_pattern_update(self) -> Dict[str, int]:
-        """Full pattern analysis of all memories for active profile. Run this weekly."""
-        active_profile = self._get_active_profile()
-        print(f"Starting weekly pattern update for profile: {active_profile}...")
-
-        # Get memory IDs for active profile only
-        conn = sqlite3.connect(self.db_path)
-        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.")
-            return {'preferences': 0, 'styles': 0, 'terminology': 0}
-
-        print(f"Analyzing {total_memories} memories for profile '{active_profile}'...")
-
-        # Run all analyzers
-        preferences = self.frequency_analyzer.analyze_preferences(all_memory_ids)
-        print(f"  Found {len(preferences)} preference patterns")
-
-        styles = self.context_analyzer.analyze_style(all_memory_ids)
-        print(f"  Found {len(styles)} style patterns")
-
-        terms = self.terminology_learner.learn_terminology(all_memory_ids)
-        print(f"  Found {len(terms)} terminology patterns")
-
-        # Recalculate confidence scores and save all patterns (tagged with profile)
-        counts = {'preferences': 0, 'styles': 0, 'terminology': 0}
-
-        for pattern in preferences.values():
-            confidence = self.confidence_scorer.calculate_confidence(
-                pattern['pattern_type'],
-                pattern['key'],
-                pattern['value'],
-                pattern['memory_ids'],
-                total_memories
-            )
-            pattern['confidence'] = round(confidence, 2)
-            pattern['profile'] = active_profile
-            self.pattern_store.save_pattern(pattern)
-            counts['preferences'] += 1
-
-        for pattern in styles.values():
-            confidence = self.confidence_scorer.calculate_confidence(
-                pattern['pattern_type'],
-                pattern['key'],
-                pattern['value'],
-                pattern['memory_ids'],
-                total_memories
-            )
-            pattern['confidence'] = round(confidence, 2)
-            pattern['profile'] = active_profile
-            self.pattern_store.save_pattern(pattern)
-            counts['styles'] += 1
-
-        for pattern in terms.values():
-            confidence = self.confidence_scorer.calculate_confidence(
-                pattern['pattern_type'],
-                pattern['key'],
-                pattern['value'],
-                pattern['memory_ids'],
-                total_memories
-            )
-            pattern['confidence'] = round(confidence, 2)
-            pattern['profile'] = active_profile
-            self.pattern_store.save_pattern(pattern)
-            counts['terminology'] += 1
-
-        print(f"\nPattern update complete:")
-        print(f"  {counts['preferences']} preferences")
-        print(f"  {counts['styles']} styles")
-        print(f"  {counts['terminology']} terminology")
-
-        return counts
-
-    def on_new_memory(self, memory_id: int):
-        """Incremental update when new memory is added."""
-        active_profile = self._get_active_profile()
-        conn = sqlite3.connect(self.db_path)
-        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:
-            # Deferred to batch update for efficiency (see weekly_pattern_update)
-            pass
-        else:
-            # For small memory counts, just do full update
-            self.weekly_pattern_update()
-
-    def get_patterns(self, min_confidence: float = 0.7) -> List[Dict[str, Any]]:
-        """Query patterns above confidence threshold for active profile."""
-        active_profile = self._get_active_profile()
-        return self.pattern_store.get_patterns(min_confidence, profile=active_profile)
-
-    def get_identity_context(self, min_confidence: float = 0.7) -> str:
-        """Format patterns for Claude context injection."""
-        patterns = self.get_patterns(min_confidence)
-
-        if not patterns:
-            return "## Working with User - Learned Patterns\n\nNo patterns learned yet. Add more memories to build your profile."
-
-        # Group by pattern type
-        sections = {
-            'preference': [],
-            'style': [],
-            'terminology': []
-        }
-
-        for p in patterns:
-            sections[p['pattern_type']].append(
-                f"- **{p['key'].replace('_', ' ').title()}:** {p['value']} "
-                f"(confidence: {p['confidence']:.0%}, {p['evidence_count']} examples)"
-            )
-
-        output = "## Working with User - Learned Patterns\n\n"
-
-        if sections['preference']:
-            output += "**Technology Preferences:**\n" + '\n'.join(sections['preference']) + '\n\n'
-
-        if sections['style']:
-            output += "**Coding Style:**\n" + '\n'.join(sections['style']) + '\n\n'
-
-        if sections['terminology']:
-            output += "**Terminology:**\n" + '\n'.join(sections['terminology']) + '\n'
-
-        return output
-
-
-# CLI Interface
-if __name__ == "__main__":
-    import sys
-
-    learner = PatternLearner()
-
-    if len(sys.argv) < 2:
-        print("Pattern Learner - Identity Profile Extraction")
-        print("\nUsage:")
-        print("  python pattern_learner.py update           # Full pattern update (weekly)")
-        print("  python pattern_learner.py list [min_conf]  # List learned patterns (default: 0.7)")
-        print("  python pattern_learner.py context [min]    # Get context for Claude")
-        print("  python pattern_learner.py stats            # Pattern statistics")
-        sys.exit(0)
-
-    command = sys.argv[1]
-
-    if command == "update":
-        counts = learner.weekly_pattern_update()
-        print(f"\nTotal patterns learned: {sum(counts.values())}")
-
-    elif command == "list":
-        min_conf = float(sys.argv[2]) if len(sys.argv) > 2 else 0.7
-        patterns = learner.get_patterns(min_conf)
-
-        if not patterns:
-            print(f"No patterns found with confidence >= {min_conf:.0%}")
-        else:
-            print(f"\n{'Type':<15} {'Category':<12} {'Pattern':<30} {'Confidence':<12} {'Evidence':<10}")
-            print("-" * 95)
-
-            for p in patterns:
-                pattern_display = f"{p['key'].replace('_', ' ').title()}: {p['value']}"
-                if len(pattern_display) > 28:
-                    pattern_display = pattern_display[:28] + "..."
-
-                print(f"{p['pattern_type']:<15} {p['category']:<12} {pattern_display:<30} "
-                      f"{p['confidence']:>6.0%}        {p['evidence_count']:<10}")
-
-    elif command == "context":
-        min_conf = float(sys.argv[2]) if len(sys.argv) > 2 else 0.7
-        context = learner.get_identity_context(min_conf)
-        print(context)
-
-    elif command == "stats":
-        patterns = learner.get_patterns(0.5)  # Include all patterns
-
-        if not patterns:
-            print("No patterns learned yet.")
-        else:
-            by_type = Counter([p['pattern_type'] for p in patterns])
-            by_category = Counter([p['category'] for p in patterns])
-
-            avg_confidence = sum(p['confidence'] for p in patterns) / len(patterns)
-            high_conf = len([p for p in patterns if p['confidence'] >= 0.8])
-
-            print(f"\nPattern Statistics:")
-            print(f"  Total patterns: {len(patterns)}")
-            print(f"  Average confidence: {avg_confidence:.0%}")
-            print(f"  High confidence (>=80%): {high_conf}")
-            print(f"\nBy Type:")
-            for ptype, count in by_type.most_common():
-                print(f"  {ptype}: {count}")
-            print(f"\nBy Category:")
-            for cat, count in by_category.most_common():
-                print(f"  {cat}: {count}")
-
-    else:
-        print(f"Unknown command: {command}")
-        sys.exit(1)

package/src/patterns/scoring.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""
-Confidence Scoring - Bayesian pattern confidence calculation.
-
-Uses Beta-Binomial posterior with log-scaled competition,
-recency bonuses, and temporal distribution factors.
-"""
-
-import sqlite3
-import logging
-from datetime import datetime, timedelta
-from typing import List
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-
-class ConfidenceScorer:
-    """Calculates and tracks pattern confidence scores."""
-
-    def __init__(self, db_path: Path):
-        self.db_path = db_path
-
-    def calculate_confidence(
-        self,
-        pattern_type: str,
-        key: str,
-        value: str,
-        evidence_memory_ids: List[int],
-        total_memories: int
-    ) -> float:
-        """
-        Calculate confidence using Beta-Binomial Bayesian posterior.
-
-        Based on MACLA (arXiv:2512.18950, Forouzandeh et al., Dec 2025):
-          posterior_mean = (alpha + evidence) / (alpha + beta + evidence + competition)
-
-        Adaptation: MACLA's Beta-Binomial uses pairwise interaction counts.
-        Our corpus has sparse signals (most memories are irrelevant to any
-        single pattern). We use log-scaled competition instead of raw total
-        to avoid over-dilution: competition = log2(total_memories).
-
-        Pattern-specific priors (alpha, beta):
-        - preference (1, 4): prior mean 0.20, ~8 items to reach 0.5
-        - style (1, 5): prior mean 0.17, subtler signals need more evidence
-        - terminology (2, 3): prior mean 0.40, direct usage signal
-        """
-        if total_memories == 0 or not evidence_memory_ids:
-            return 0.0
-
-        import math
-        evidence_count = len(evidence_memory_ids)
-
-        # Pattern-specific Beta priors (alpha, beta)
-        PRIORS = {
-            'preference': (1.0, 4.0),
-            'style':      (1.0, 5.0),
-            'terminology': (2.0, 3.0),
-        }
-        alpha, beta = PRIORS.get(pattern_type, (1.0, 4.0))
-
-        # Log-scaled competition: grows slowly with corpus size
-        # 10 memories -> 3.3, 60 -> 5.9, 500 -> 9.0, 5000 -> 12.3
-        competition = math.log2(max(2, total_memories))
-
-        # MACLA-inspired Beta posterior with log competition
-        posterior_mean = (alpha + evidence_count) / (alpha + beta + evidence_count + competition)
-
-        # Recency adjustment (mild: 1.0 to 1.15)
-        recency_bonus = self._calculate_recency_bonus(evidence_memory_ids)
-        recency_factor = 1.0 + min(0.15, 0.075 * (recency_bonus - 1.0) / 0.2) if recency_bonus > 1.0 else 1.0
-
-        # Temporal spread adjustment (0.9 to 1.1)
-        distribution_factor = self._calculate_distribution_factor(evidence_memory_ids)
-
-        # Final confidence
-        confidence = posterior_mean * recency_factor * distribution_factor
-
-        return min(0.95, round(confidence, 3))
-
-    def _calculate_recency_bonus(self, memory_ids: List[int]) -> float:
-        """Give bonus to patterns with recent evidence."""
-        conn = sqlite3.connect(self.db_path)
-        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)
-
-            timestamps = cursor.fetchall()
-        finally:
-            conn.close()
-
-        if not timestamps:
-            return 1.0
-
-        # Check if any memories are from last 30 days
-        recent_count = 0
-        cutoff = datetime.now() - timedelta(days=30)
-
-        for ts_tuple in timestamps:
-            ts_str = ts_tuple[0]
-            try:
-                ts = datetime.fromisoformat(ts_str.replace(' ', 'T'))
-                if ts > cutoff:
-                    recent_count += 1
-            except (ValueError, AttributeError):
-                pass
-
-        # Bonus if >50% are recent
-        if len(timestamps) > 0 and recent_count / len(timestamps) > 0.5:
-            return 1.2
-        else:
-            return 1.0
-
-    def _calculate_distribution_factor(self, memory_ids: List[int]) -> float:
-        """Better confidence if memories are distributed over time, not just one session."""
-        if len(memory_ids) < 3:
-            return 0.8  # Penalize low sample size
-
-        conn = sqlite3.connect(self.db_path)
-        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
-
-        try:
-            # Parse timestamps
-            dates = []
-            for ts_str in timestamps:
-                try:
-                    ts = datetime.fromisoformat(ts_str.replace(' ', 'T'))
-                    dates.append(ts)
-                except (ValueError, AttributeError):
-                    pass
-
-            if len(dates) < 2:
-                return 0.8
-
-            # Calculate time span
-            time_span = (dates[-1] - dates[0]).days
-
-            # If memories span multiple days, higher confidence
-            if time_span > 7:
-                return 1.1
-            elif time_span > 1:
-                return 1.0
-            else:
-                return 0.9  # All on same day = might be one-off
-
-        except Exception:
-            return 1.0