superlocalmemory 2.8.5 → 3.0.0

package/src/learning/tests/test_adaptive_ranker.py

@@ -1,325 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-import pytest
-
-
-# Detect optional dependencies at import time
-try:
-    import lightgbm
-    HAS_LIGHTGBM = True
-except ImportError:
-    HAS_LIGHTGBM = False
-
-try:
-    import numpy as np
-    HAS_NUMPY = True
-except ImportError:
-    np = None
-    HAS_NUMPY = False
-
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-@pytest.fixture(autouse=True)
-def reset_singleton():
-    from src.learning.learning_db import LearningDB
-    LearningDB.reset_instance()
-    yield
-    LearningDB.reset_instance()
-
-
-@pytest.fixture
-def learning_db(tmp_path):
-    from src.learning.learning_db import LearningDB
-    db_path = tmp_path / "learning.db"
-    return LearningDB(db_path=db_path)
-
-
-@pytest.fixture
-def ranker(learning_db):
-    from src.learning.adaptive_ranker import AdaptiveRanker
-    return AdaptiveRanker(learning_db=learning_db)
-
-
-def _make_result(memory_id, score=0.5, content="test memory", importance=5,
-                 project_name=None, created_at="2026-02-16 10:00:00",
-                 access_count=0, match_type="keyword"):
-    """Helper to build a search result dict."""
-    return {
-        "id": memory_id,
-        "content": content,
-        "score": score,
-        "match_type": match_type,
-        "importance": importance,
-        "created_at": created_at,
-        "access_count": access_count,
-        "project_name": project_name,
-        "tags": [],
-        "created_by": None,
-    }
-
-
-# ---------------------------------------------------------------------------
-# Phase Detection
-# ---------------------------------------------------------------------------
-
-class TestGetPhase:
-    def test_baseline_with_zero_signals(self, ranker):
-        assert ranker.get_phase() == "baseline"
-
-    def test_baseline_with_few_signals(self, ranker, learning_db):
-        """Less than 20 signals should stay in baseline."""
-        for i in range(10):
-            learning_db.store_feedback(
-                query_hash=f"q{i}",
-                memory_id=i,
-                signal_type="mcp_used",
-            )
-        assert ranker.get_phase() == "baseline"
-
-    def test_rule_based_at_20_signals(self, ranker, learning_db):
-        """20+ signals should enter rule_based phase."""
-        for i in range(25):
-            learning_db.store_feedback(
-                query_hash=f"q{i}",
-                memory_id=i,
-                signal_type="mcp_used",
-            )
-        assert ranker.get_phase() == "rule_based"
-
-    @pytest.mark.skipif(not HAS_LIGHTGBM or not HAS_NUMPY,
-                        reason="LightGBM/NumPy required for ML phase")
-    def test_ml_model_at_200_signals(self, ranker, learning_db):
-        """200+ signals across 50+ queries should trigger ml_model."""
-        for i in range(250):
-            learning_db.store_feedback(
-                query_hash=f"q{i % 60}",  # 60 unique queries
-                memory_id=i,
-                signal_type="mcp_used",
-            )
-        assert ranker.get_phase() == "ml_model"
-
-    def test_ml_model_requires_enough_unique_queries(self, ranker, learning_db):
-        """200+ signals but only 10 unique queries should stay rule_based."""
-        for i in range(250):
-            learning_db.store_feedback(
-                query_hash=f"q{i % 10}",  # Only 10 unique queries
-                memory_id=i,
-                signal_type="mcp_used",
-            )
-        # Even with LightGBM available, not enough unique queries
-        phase = ranker.get_phase()
-        assert phase in ("rule_based", "ml_model")
-        if HAS_LIGHTGBM and HAS_NUMPY:
-            assert phase == "rule_based"  # 10 < 50 unique queries
-
-    def test_no_learning_db_auto_creates(self):
-        """v2.7.2+: AdaptiveRanker auto-creates LearningDB. Phase depends on existing data."""
-        from src.learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker(learning_db=None)
-        phase = ranker.get_phase()
-        # Phase is valid (auto-created DB may have data from other tests)
-        assert phase in ("baseline", "rule_based", "ml_model")
-
-
-# ---------------------------------------------------------------------------
-# Phase Info
-# ---------------------------------------------------------------------------
-
-class TestGetPhaseInfo:
-    def test_phase_info_structure(self, ranker):
-        info = ranker.get_phase_info()
-        assert "phase" in info
-        assert "feedback_count" in info
-        assert "unique_queries" in info
-        assert "thresholds" in info
-        assert "model_loaded" in info
-        assert "lightgbm_available" in info
-        assert "numpy_available" in info
-
-    def test_phase_info_values(self, ranker):
-        info = ranker.get_phase_info()
-        assert info["phase"] == "baseline"
-        assert info["feedback_count"] == 0
-        assert info["unique_queries"] == 0
-        assert info["model_loaded"] is False
-
-
-# ---------------------------------------------------------------------------
-# Rerank Routing
-# ---------------------------------------------------------------------------
-
-class TestRerank:
-    def test_empty_results(self, ranker):
-        result = ranker.rerank([], "query")
-        assert result == []
-
-    def test_single_result_baseline(self, ranker):
-        """Single result should get baseline phase annotation."""
-        results = [_make_result(1, score=0.8)]
-        reranked = ranker.rerank(results, "test query")
-        assert len(reranked) == 1
-        assert reranked[0]["ranking_phase"] == "baseline"
-        assert reranked[0]["base_score"] == 0.8
-
-    def test_baseline_preserves_order(self, ranker):
-        """In baseline phase, original order should be preserved."""
-        results = [
-            _make_result(1, score=0.9),
-            _make_result(2, score=0.5),
-            _make_result(3, score=0.3),
-        ]
-        reranked = ranker.rerank(results, "test query")
-        # All should be baseline
-        for r in reranked:
-            assert r["ranking_phase"] == "baseline"
-        # Order preserved (no re-sorting in baseline)
-        assert reranked[0]["id"] == 1
-        assert reranked[1]["id"] == 2
-        assert reranked[2]["id"] == 3
-
-    def test_base_score_preserved(self, ranker, learning_db):
-        """base_score should always contain the original score."""
-        # Add enough feedback for rule_based
-        for i in range(25):
-            learning_db.store_feedback(
-                query_hash=f"q{i}", memory_id=i, signal_type="mcp_used",
-            )
-
-        results = [
-            _make_result(1, score=0.8),
-            _make_result(2, score=0.5),
-        ]
-        reranked = ranker.rerank(results, "test query")
-        for r in reranked:
-            assert "base_score" in r
-
-
-# ---------------------------------------------------------------------------
-# Rule-Based Re-ranking
-# ---------------------------------------------------------------------------
-
-class TestRuleBasedReranking:
-    def test_boost_applied(self, ranker, learning_db):
-        """Rule-based should modify scores based on features."""
-        for i in range(25):
-            learning_db.store_feedback(
-                query_hash=f"q{i}", memory_id=i, signal_type="mcp_used",
-            )
-
-        results = [
-            _make_result(1, score=0.5, importance=9, access_count=8),
-            _make_result(2, score=0.5, importance=2, access_count=0),
-        ]
-        reranked = ranker.rerank(results, "test query")
-
-        # Both should be rule_based
-        assert all(r["ranking_phase"] == "rule_based" for r in reranked)
-
-        # High importance + access should get higher score
-        high_imp = next(r for r in reranked if r["id"] == 1)
-        low_imp = next(r for r in reranked if r["id"] == 2)
-        assert high_imp["score"] > low_imp["score"]
-
-    def test_project_match_boost(self, ranker, learning_db):
-        """Memory matching current project should be boosted."""
-        for i in range(25):
-            learning_db.store_feedback(
-                query_hash=f"q{i}", memory_id=i, signal_type="mcp_used",
-            )
-
-        results = [
-            _make_result(1, score=0.5, project_name="SLM"),
-            _make_result(2, score=0.5, project_name="OTHER"),
-        ]
-        context = {"current_project": "SLM"}
-        reranked = ranker.rerank(results, "test query", context=context)
-
-        slm_result = next(r for r in reranked if r["id"] == 1)
-        other_result = next(r for r in reranked if r["id"] == 2)
-        assert slm_result["score"] > other_result["score"]
-
-    def test_results_resorted(self, ranker, learning_db):
-        """Results should be re-sorted by boosted score."""
-        for i in range(25):
-            learning_db.store_feedback(
-                query_hash=f"q{i}", memory_id=i, signal_type="mcp_used",
-            )
-
-        # Second result has much higher importance
-        results = [
-            _make_result(1, score=0.5, importance=2),
-            _make_result(2, score=0.5, importance=10, access_count=10),
-        ]
-        reranked = ranker.rerank(results, "test query")
-        # Higher importance should float to top
-        assert reranked[0]["id"] == 2
-
-
-# ---------------------------------------------------------------------------
-# ML Training (skipped if LightGBM not available)
-# ---------------------------------------------------------------------------
-
-class TestTraining:
-    @pytest.mark.skipif(not HAS_LIGHTGBM or not HAS_NUMPY,
-                        reason="LightGBM/NumPy required")
-    def test_train_insufficient_data(self, ranker, learning_db):
-        """Training should return None with insufficient data."""
-        result = ranker.train()
-        assert result is None
-
-    def test_train_without_lightgbm(self, ranker):
-        """Should gracefully handle missing LightGBM."""
-        from src.learning import adaptive_ranker as ar_module
-        original = ar_module.HAS_LIGHTGBM
-        ar_module.HAS_LIGHTGBM = False
-        try:
-            result = ranker.train()
-            assert result is None
-        finally:
-            ar_module.HAS_LIGHTGBM = original
-
-
-# ---------------------------------------------------------------------------
-# Model Loading Fallback
-# ---------------------------------------------------------------------------
-
-class TestModelLoading:
-    def test_load_nonexistent_model(self, ranker):
-        """Loading a model that doesn't exist should return None."""
-        model = ranker._load_model()
-        assert model is None
-
-    def test_load_attempt_cached(self, ranker):
-        """After first failed load, _model_load_attempted should be True."""
-        ranker._load_model()
-        assert ranker._model_load_attempted is True
-
-    def test_second_load_returns_cached_none(self, ranker):
-        """Second load attempt should return None immediately (cached failure)."""
-        ranker._load_model()
-        result = ranker._load_model()
-        assert result is None
-
-    def test_reload_model_resets_flag(self, ranker):
-        """reload_model should reset the _model_load_attempted flag."""
-        ranker._load_model()
-        assert ranker._model_load_attempted is True
-        ranker.reload_model()
-        # After reload, the flag should have been reset and tried again
-        # (and failed again since no model file exists)
-        assert ranker._model is None
-
-
-# ---------------------------------------------------------------------------
-# Module-level convenience
-# ---------------------------------------------------------------------------
-
-class TestModuleLevel:
-    def test_get_phase_function(self):
-        from src.learning.adaptive_ranker import get_phase
-        phase = get_phase()
-        assert phase in ("baseline", "rule_based", "ml_model")

package/src/learning/tests/test_adaptive_ranker_v28.py

@@ -1,60 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for v2.8 adaptive ranker — 20 features + lifecycle/behavioral boosts.
-"""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestAdaptiveRankerV28:
-    def test_num_features_is_20(self):
-        from learning.feature_extractor import NUM_FEATURES
-        assert NUM_FEATURES == 20
-
-    def test_new_rule_boosts_exist(self):
-        from learning.adaptive_ranker import _RULE_BOOST
-        assert 'lifecycle_active' in _RULE_BOOST
-        assert 'outcome_success_high' in _RULE_BOOST
-        assert 'behavioral_match_strong' in _RULE_BOOST
-        assert 'cross_project_boost' in _RULE_BOOST
-
-    def test_lifecycle_active_boost(self):
-        from learning.adaptive_ranker import _RULE_BOOST
-        assert _RULE_BOOST['lifecycle_active'] == 1.0
-        assert _RULE_BOOST['lifecycle_warm'] == 0.85
-        assert _RULE_BOOST['lifecycle_cold'] == 0.6
-
-    def test_outcome_boosts(self):
-        from learning.adaptive_ranker import _RULE_BOOST
-        assert _RULE_BOOST['outcome_success_high'] == 1.3
-        assert _RULE_BOOST['outcome_failure_high'] == 0.7
-
-    def test_phase1_works_with_20_features(self):
-        """Phase 1 (rule-based) ranking should work with 20-feature vectors."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-        results = [
-            {'id': 1, 'content': 'Python memory', 'score': 0.8, 'match_type': 'semantic',
-             'importance': 7, 'lifecycle_state': 'active'},
-            {'id': 2, 'content': 'Old memory', 'score': 0.7, 'match_type': 'semantic',
-             'importance': 3, 'lifecycle_state': 'cold'},
-        ]
-        ranked = ranker.rerank(results, "Python")
-        assert len(ranked) == 2
-        assert all('score' in r for r in ranked)
-
-    def test_active_memory_ranks_higher_than_cold(self):
-        """Active memories should score higher than cold with same base score."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-        results = [
-            {'id': 1, 'content': 'same content', 'score': 0.8, 'match_type': 'semantic',
-             'importance': 5, 'lifecycle_state': 'cold'},
-            {'id': 2, 'content': 'same content', 'score': 0.8, 'match_type': 'semantic',
-             'importance': 5, 'lifecycle_state': 'active'},
-        ]
-        ranked = ranker.rerank(results, "test")
-        # Active (id=2) should rank higher than cold (id=1)
-        if len(ranked) >= 2:
-            assert ranked[0]['id'] == 2 or ranked[0]['score'] >= ranked[1]['score']

package/src/learning/tests/test_aggregator.py

@@ -1,306 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-import math
-import sqlite3
-from datetime import datetime, timedelta
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-import pytest
-
-
-# ---------------------------------------------------------------------------
-# Fixtures
-# ---------------------------------------------------------------------------
-
-@pytest.fixture(autouse=True)
-def reset_singleton():
-    from src.learning.learning_db import LearningDB
-    LearningDB.reset_instance()
-    yield
-    LearningDB.reset_instance()
-
-
-@pytest.fixture
-def learning_db(tmp_path):
-    from src.learning.learning_db import LearningDB
-    db_path = tmp_path / "learning.db"
-    return LearningDB(db_path=db_path)
-
-
-@pytest.fixture
-def memory_db(tmp_path):
-    """Create a minimal memory.db with test data."""
-    db_path = tmp_path / "memory.db"
-    conn = sqlite3.connect(str(db_path))
-    cursor = conn.cursor()
-    cursor.execute('''
-        CREATE TABLE IF NOT EXISTS memories (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            content TEXT NOT NULL,
-            summary TEXT,
-            project_path TEXT,
-            project_name TEXT,
-            tags TEXT DEFAULT '[]',
-            category TEXT,
-            parent_id INTEGER,
-            tree_path TEXT DEFAULT '/',
-            depth INTEGER DEFAULT 0,
-            memory_type TEXT DEFAULT 'session',
-            importance INTEGER DEFAULT 5,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            last_accessed TIMESTAMP,
-            access_count INTEGER DEFAULT 0,
-            content_hash TEXT,
-            cluster_id INTEGER,
-            profile TEXT DEFAULT 'default',
-            created_by TEXT,
-            source_protocol TEXT,
-            trust_score REAL DEFAULT 1.0
-        )
-    ''')
-    conn.commit()
-    conn.close()
-    return db_path
-
-
-def _insert_memories(db_path, memories):
-    conn = sqlite3.connect(str(db_path))
-    cursor = conn.cursor()
-    for m in memories:
-        cursor.execute('''
-            INSERT INTO memories (content, tags, project_name, project_path,
-                                  importance, access_count, profile, created_by,
-                                  source_protocol, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-        ''', (
-            m.get('content', 'test'),
-            m.get('tags', '[]'),
-            m.get('project_name'),
-            m.get('project_path'),
-            m.get('importance', 5),
-            m.get('access_count', 0),
-            m.get('profile', 'default'),
-            m.get('created_by'),
-            m.get('source_protocol'),
-            m.get('created_at', '2026-02-16 10:00:00'),
-        ))
-    conn.commit()
-    conn.close()
-
-
-# ---------------------------------------------------------------------------
-# Temporal Decay
-# ---------------------------------------------------------------------------
-
-class TestTemporalDecay:
-    def test_days_since_recent(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        now = datetime(2026, 2, 16, 12, 0, 0)
-        ts = "2026-02-16T10:00:00"
-        days = CrossProjectAggregator._days_since(ts, now)
-        assert 0.0 <= days < 1.0
-
-    def test_days_since_365_days_ago(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        now = datetime(2026, 2, 16, 12, 0, 0)
-        old = (now - timedelta(days=365)).isoformat()
-        days = CrossProjectAggregator._days_since(old, now)
-        assert abs(days - 365.0) < 1.0
-
-    def test_days_since_empty_string(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        assert CrossProjectAggregator._days_since("") == 0.0
-
-    def test_days_since_invalid_string(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        assert CrossProjectAggregator._days_since("not-a-date") == 0.0
-
-    def test_days_since_space_separated(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        now = datetime(2026, 2, 16, 12, 0, 0)
-        ts = "2026-02-15 12:00:00"
-        days = CrossProjectAggregator._days_since(ts, now)
-        assert abs(days - 1.0) < 0.01
-
-    def test_decay_weight_recent(self):
-        """Recent timestamp -> weight close to 1.0."""
-        from src.learning.cross_project_aggregator import DECAY_HALF_LIFE_DAYS
-        # 0 days -> exp(0) = 1.0
-        weight = math.exp(-0.0 / DECAY_HALF_LIFE_DAYS)
-        assert abs(weight - 1.0) < 0.001
-
-    def test_decay_weight_365_days(self):
-        """365-day-old pattern -> weight ~ 0.37."""
-        from src.learning.cross_project_aggregator import DECAY_HALF_LIFE_DAYS
-        weight = math.exp(-365.0 / DECAY_HALF_LIFE_DAYS)
-        assert 0.30 < weight < 0.40
-
-
-# ---------------------------------------------------------------------------
-# Contradiction Detection
-# ---------------------------------------------------------------------------
-
-class TestContradictionDetection:
-    def test_cross_profile_disagreement(self, learning_db, memory_db):
-        """Two profiles with different values should trigger a contradiction."""
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-
-        pattern_data = {
-            "value": "react",
-            "profile_history": [
-                {"profile": "work", "value": "react", "confidence": 0.8,
-                 "weight": 1.0, "timestamp": "2026-02-16"},
-                {"profile": "personal", "value": "vue", "confidence": 0.7,
-                 "weight": 0.9, "timestamp": "2026-02-15"},
-            ],
-        }
-
-        contradictions = aggregator._detect_contradictions("frontend", pattern_data)
-        assert len(contradictions) >= 1
-        assert any("vue" in c and "react" in c for c in contradictions)
-
-    def test_no_contradiction_when_unanimous(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        pattern_data = {
-            "value": "python",
-            "profile_history": [
-                {"profile": "work", "value": "python", "confidence": 0.9,
-                 "weight": 1.0, "timestamp": "2026-02-16"},
-                {"profile": "personal", "value": "python", "confidence": 0.8,
-                 "weight": 0.9, "timestamp": "2026-02-15"},
-            ],
-        }
-        contradictions = aggregator._detect_contradictions("lang", pattern_data)
-        assert len(contradictions) == 0
-
-
-# ---------------------------------------------------------------------------
-# get_tech_preferences from learning.db
-# ---------------------------------------------------------------------------
-
-class TestGetTechPreferences:
-    def test_empty_db_returns_empty(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        prefs = aggregator.get_tech_preferences(min_confidence=0.0)
-        assert prefs == {}
-
-    def test_stored_patterns_returned(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-
-        # Pre-populate learning.db with a preference pattern
-        learning_db.upsert_transferable_pattern(
-            pattern_type="preference",
-            key="language",
-            value="python",
-            confidence=0.85,
-            evidence_count=15,
-            profiles_seen=2,
-        )
-
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        prefs = aggregator.get_tech_preferences(min_confidence=0.5)
-        assert "language" in prefs
-        assert prefs["language"]["value"] == "python"
-        assert prefs["language"]["confidence"] == 0.85
-
-    def test_confidence_filter(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-
-        learning_db.upsert_transferable_pattern(
-            pattern_type="preference", key="low", value="x",
-            confidence=0.3, evidence_count=2,
-        )
-        learning_db.upsert_transferable_pattern(
-            pattern_type="preference", key="high", value="y",
-            confidence=0.9, evidence_count=20,
-        )
-
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        prefs = aggregator.get_tech_preferences(min_confidence=0.6)
-        assert "high" in prefs
-        assert "low" not in prefs
-
-    def test_no_learning_db_auto_creates(self, memory_db):
-        """v2.7.2+: Aggregator auto-creates LearningDB. Should not crash."""
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=None,
-        )
-        # Should not crash — may return data from auto-created DB
-        prefs = aggregator.get_tech_preferences()
-        assert isinstance(prefs, dict)
-
-
-# ---------------------------------------------------------------------------
-# is_within_window
-# ---------------------------------------------------------------------------
-
-class TestIsWithinWindow:
-    def test_recent_within_window(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        now_str = datetime.now().isoformat()
-        assert CrossProjectAggregator._is_within_window(now_str, 90) is True
-
-    def test_old_outside_window(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        old = (datetime.now() - timedelta(days=200)).isoformat()
-        assert CrossProjectAggregator._is_within_window(old, 90) is False
-
-    def test_empty_timestamp(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        assert CrossProjectAggregator._is_within_window("", 90) is False
-
-    def test_invalid_timestamp(self):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        assert CrossProjectAggregator._is_within_window("not-a-date", 90) is False
-
-
-# ---------------------------------------------------------------------------
-# Preference Context Formatting
-# ---------------------------------------------------------------------------
-
-class TestPreferenceContext:
-    def test_no_preferences(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        ctx = aggregator.get_preference_context()
-        assert "No transferable preferences learned yet" in ctx
-
-    def test_with_preferences(self, learning_db, memory_db):
-        from src.learning.cross_project_aggregator import CrossProjectAggregator
-        learning_db.upsert_transferable_pattern(
-            pattern_type="preference", key="framework", value="FastAPI",
-            confidence=0.8, evidence_count=10, profiles_seen=2,
-        )
-        aggregator = CrossProjectAggregator(
-            memory_db_path=memory_db,
-            learning_db=learning_db,
-        )
-        ctx = aggregator.get_preference_context(min_confidence=0.5)
-        assert "FastAPI" in ctx
-        assert "Framework" in ctx  # Title-cased key