superlocalmemory 2.8.6 → 3.0.0

package/src/learning/tests/test_auto_retrain_v28.py

@@ -1,35 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for auto-retrain mechanism when feature dimensions change 12->20.
-"""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestAutoRetrain:
-    def test_feature_dimension_is_20(self):
-        from learning.feature_extractor import NUM_FEATURES
-        assert NUM_FEATURES == 20
-
-    def test_ranker_handles_dimension_mismatch(self):
-        """Ranker should not crash when loaded model has different dimensions."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-        # Even without a trained model, phase 1 should work
-        results = [{'id': 1, 'content': 'test', 'score': 0.5, 'match_type': 'semantic', 'importance': 5}]
-        ranked = ranker.rerank(results, "test")
-        assert len(ranked) == 1
-
-    def test_phase1_immediate_during_retrain(self):
-        """Phase 1 (rule-based) should work immediately even during model retrain."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-        results = [
-            {'id': 1, 'content': 'memory A', 'score': 0.9, 'match_type': 'semantic', 'importance': 8},
-            {'id': 2, 'content': 'memory B', 'score': 0.3, 'match_type': 'keyword', 'importance': 2},
-        ]
-        ranked = ranker.rerank(results, "test query")
-        assert len(ranked) == 2
-        # Higher base score should still rank first in phase 1
-        assert ranked[0]['score'] >= ranked[1]['score']

package/src/learning/tests/test_e2e_ranking_v28.py

@@ -1,82 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""End-to-end tests for adaptive ranking with 20-feature vector.
-"""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestE2ERankingV28:
-    def test_full_20_feature_pipeline(self):
-        """Full pipeline: extract 20 features -> rank results."""
-        from learning.feature_extractor import FeatureExtractor
-        from learning.adaptive_ranker import AdaptiveRanker
-
-        extractor = FeatureExtractor()
-        ranker = AdaptiveRanker()
-
-        memories = [
-            {'id': 1, 'content': 'Python best practices for production', 'score': 0.8,
-             'match_type': 'semantic', 'importance': 8, 'lifecycle_state': 'active',
-             'access_count': 15, 'created_at': '2026-02-01'},
-            {'id': 2, 'content': 'Old JavaScript patterns deprecated', 'score': 0.75,
-             'match_type': 'semantic', 'importance': 3, 'lifecycle_state': 'cold',
-             'access_count': 1, 'created_at': '2025-06-01'},
-        ]
-
-        # Extract features
-        for mem in memories:
-            features = extractor.extract_features(mem, "Python production")
-            assert len(features) == 20
-
-        # Rank
-        ranked = ranker.rerank(memories, "Python production")
-        assert len(ranked) == 2
-
-    def test_lifecycle_affects_ranking(self):
-        """Active memories should generally rank above cold ones."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-
-        results = [
-            {'id': 1, 'content': 'cold memory', 'score': 0.85, 'match_type': 'semantic',
-             'importance': 5, 'lifecycle_state': 'cold'},
-            {'id': 2, 'content': 'active memory', 'score': 0.80, 'match_type': 'semantic',
-             'importance': 5, 'lifecycle_state': 'active'},
-        ]
-        ranked = ranker.rerank(results, "test")
-        # Even with slightly lower base score, active should win due to lifecycle boost
-        assert ranked[0]['id'] == 2
-
-    def test_high_outcome_success_boosts_ranking(self):
-        """Memories with high success rates should rank higher."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-
-        results = [
-            {'id': 1, 'content': 'frequently failing', 'score': 0.8, 'match_type': 'semantic',
-             'importance': 5, 'outcome_success_rate': 0.1},
-            {'id': 2, 'content': 'consistently useful', 'score': 0.8, 'match_type': 'semantic',
-             'importance': 5, 'outcome_success_rate': 0.95},
-        ]
-        ranked = ranker.rerank(results, "test")
-        assert ranked[0]['id'] == 2
-
-    def test_result_ordering_reflects_all_signals(self):
-        """Result ordering should reflect lifecycle + behavioral + base score."""
-        from learning.adaptive_ranker import AdaptiveRanker
-        ranker = AdaptiveRanker()
-
-        results = [
-            {'id': 1, 'content': 'A', 'score': 0.7, 'match_type': 'semantic', 'importance': 5,
-             'lifecycle_state': 'active', 'outcome_success_rate': 0.9},
-            {'id': 2, 'content': 'B', 'score': 0.9, 'match_type': 'semantic', 'importance': 5,
-             'lifecycle_state': 'cold', 'outcome_success_rate': 0.1},
-            {'id': 3, 'content': 'C', 'score': 0.8, 'match_type': 'semantic', 'importance': 8,
-             'lifecycle_state': 'active', 'outcome_success_rate': 0.5},
-        ]
-        ranked = ranker.rerank(results, "test")
-        assert len(ranked) == 3
-        # All should have final scores
-        assert all('score' in r for r in ranked)

package/src/learning/tests/test_feature_extractor_v28.py

@@ -1,93 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for v2.8 feature extractor — 20-dimensional feature vectors.
-"""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestFeatureExtractorV28:
-    def test_feature_count_is_20(self):
-        from learning.feature_extractor import FEATURE_NAMES
-        assert len(FEATURE_NAMES) == 20
-
-    def test_new_feature_names_present(self):
-        from learning.feature_extractor import FEATURE_NAMES
-        new_features = ['lifecycle_state', 'outcome_success_rate', 'outcome_count',
-                       'behavioral_match', 'cross_project_score', 'retention_priority',
-                       'trust_at_creation', 'lifecycle_aware_decay']
-        for f in new_features:
-            assert f in FEATURE_NAMES
-
-    def test_extract_returns_20_features(self):
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        memory = {
-            'id': 1, 'content': 'test memory about Python', 'importance': 5,
-            'created_at': '2026-02-20T10:00:00', 'last_accessed': '2026-02-25T10:00:00',
-            'access_count': 3, 'tags': ['python'], 'project_name': 'myproject',
-            'lifecycle_state': 'active', 'score': 0.8, 'match_type': 'semantic',
-        }
-        features = extractor.extract_features(memory, "Python programming")
-        assert len(features) == 20
-        assert all(isinstance(f, (int, float)) for f in features)
-
-    def test_lifecycle_state_encoding(self):
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        base = {'id': 1, 'content': 'test', 'importance': 5, 'created_at': '2026-02-20',
-                'access_count': 0, 'score': 0.5, 'match_type': 'semantic'}
-
-        active = extractor.extract_features({**base, 'lifecycle_state': 'active'}, "test")
-        warm = extractor.extract_features({**base, 'lifecycle_state': 'warm'}, "test")
-        cold = extractor.extract_features({**base, 'lifecycle_state': 'cold'}, "test")
-
-        assert active[12] > warm[12] > cold[12]
-
-    def test_default_values_when_data_missing(self):
-        """Features should return sensible defaults when data is unavailable."""
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        minimal = {'id': 1, 'content': 'test', 'importance': 5, 'score': 0.5, 'match_type': 'semantic'}
-        features = extractor.extract_features(minimal, "test")
-        assert len(features) == 20
-        # lifecycle_state default (active) = 1.0
-        assert features[12] == 1.0
-        # outcome_success_rate default = 0.5
-        assert features[13] == 0.5
-        # retention_priority default = 0.5
-        assert features[17] == 0.5
-        # trust_at_creation default = 0.8
-        assert features[18] == 0.8
-
-    def test_backward_compat_old_12_features_still_work(self):
-        """The first 12 features should still be computed correctly."""
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        memory = {'id': 1, 'content': 'Python is great', 'importance': 8,
-                  'created_at': '2026-02-20', 'access_count': 5, 'score': 0.9,
-                  'match_type': 'semantic', 'lifecycle_state': 'active'}
-        features = extractor.extract_features(memory, "Python")
-        # importance_norm (index 6) should be 0.8 (8/10)
-        assert abs(features[6] - 0.8) < 0.01
-
-    def test_extract_batch_returns_20_wide(self):
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        memories = [
-            {'id': 1, 'content': 'mem1', 'importance': 5, 'score': 0.5, 'match_type': 'semantic'},
-            {'id': 2, 'content': 'mem2', 'importance': 7, 'score': 0.7, 'match_type': 'semantic'},
-        ]
-        batch = extractor.extract_batch(memories, "test")
-        assert len(batch) == 2
-        assert all(len(v) == 20 for v in batch)
-
-    def test_outcome_success_rate_from_memory(self):
-        """If memory has outcome_success_rate in dict, use it."""
-        from learning.feature_extractor import FeatureExtractor
-        extractor = FeatureExtractor()
-        memory = {'id': 1, 'content': 'test', 'importance': 5, 'score': 0.5,
-                  'match_type': 'semantic', 'outcome_success_rate': 0.85}
-        features = extractor.extract_features(memory, "test")
-        assert abs(features[13] - 0.85) < 0.01

package/src/learning/tests/test_feedback_collector.py

@@ -1,294 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-import hashlib
-import time
-
-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 collector(learning_db):
-    from src.learning.feedback_collector import FeedbackCollector
-    return FeedbackCollector(learning_db=learning_db)
-
-
-@pytest.fixture
-def collector_no_db():
-    """Collector with no database — tests graceful degradation."""
-    from src.learning.feedback_collector import FeedbackCollector
-    return FeedbackCollector(learning_db=None)
-
-
-# ---------------------------------------------------------------------------
-# Channel 1: MCP memory_used
-# ---------------------------------------------------------------------------
-
-class TestRecordMemoryUsed:
-    def test_high_usefulness(self, collector, learning_db):
-        row_id = collector.record_memory_used(42, "deploy fastapi", usefulness="high")
-        assert row_id is not None
-
-        rows = learning_db.get_feedback_for_training()
-        assert len(rows) == 1
-        assert rows[0]["signal_type"] == "mcp_used_high"
-        assert rows[0]["signal_value"] == 1.0
-        assert rows[0]["channel"] == "mcp"
-
-    def test_medium_usefulness(self, collector, learning_db):
-        collector.record_memory_used(42, "deploy fastapi", usefulness="medium")
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["signal_type"] == "mcp_used_medium"
-        assert rows[0]["signal_value"] == 0.7
-
-    def test_low_usefulness(self, collector, learning_db):
-        collector.record_memory_used(42, "deploy fastapi", usefulness="low")
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["signal_type"] == "mcp_used_low"
-        assert rows[0]["signal_value"] == 0.4
-
-    def test_invalid_usefulness_defaults_to_high(self, collector, learning_db):
-        collector.record_memory_used(42, "test query", usefulness="INVALID")
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["signal_type"] == "mcp_used_high"
-
-    def test_empty_query_returns_none(self, collector):
-        result = collector.record_memory_used(42, "")
-        assert result is None
-
-    def test_source_tool_recorded(self, collector, learning_db):
-        collector.record_memory_used(
-            42, "test query", source_tool="claude-desktop", rank_position=2,
-        )
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["source_tool"] == "claude-desktop"
-        assert rows[0]["rank_position"] == 2
-
-    def test_no_db_auto_creates(self, collector_no_db):
-        """v2.7.2+: FeedbackCollector auto-creates LearningDB when None passed."""
-        result = collector_no_db.record_memory_used(42, "test query")
-        # Auto-created DB means this succeeds (returns row ID)
-        assert result is not None
-
-
-# ---------------------------------------------------------------------------
-# Channel 2: CLI slm useful
-# ---------------------------------------------------------------------------
-
-class TestRecordCliUseful:
-    def test_batch_ids(self, collector, learning_db):
-        row_ids = collector.record_cli_useful([10, 20, 30], "deploy fastapi")
-        assert len(row_ids) == 3
-        assert all(rid is not None for rid in row_ids)
-        assert learning_db.get_feedback_count() == 3
-
-    def test_signal_value(self, collector, learning_db):
-        collector.record_cli_useful([42], "query")
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["signal_value"] == 0.9
-        assert rows[0]["signal_type"] == "cli_useful"
-        assert rows[0]["channel"] == "cli"
-
-    def test_all_share_same_query_hash(self, collector, learning_db):
-        collector.record_cli_useful([1, 2, 3], "same query")
-        rows = learning_db.get_feedback_for_training()
-        hashes = {r["query_hash"] for r in rows}
-        assert len(hashes) == 1
-
-    def test_empty_query(self, collector):
-        result = collector.record_cli_useful([1, 2], "")
-        assert result == [None, None]
-
-
-# ---------------------------------------------------------------------------
-# Channel 3: Dashboard click
-# ---------------------------------------------------------------------------
-
-class TestRecordDashboardClick:
-    def test_basic_click(self, collector, learning_db):
-        row_id = collector.record_dashboard_click(42, "test query")
-        assert row_id is not None
-        rows = learning_db.get_feedback_for_training()
-        assert rows[0]["signal_type"] == "dashboard_click"
-        assert rows[0]["signal_value"] == 0.8
-        assert rows[0]["channel"] == "dashboard"
-
-    def test_with_dwell_time(self, collector, learning_db):
-        collector.record_dashboard_click(42, "test query", dwell_time=15.3)
-        # dwell_time is stored in ranking_feedback but not in training export
-        # Verify via direct DB query
-        conn = learning_db._get_connection()
-        cursor = conn.cursor()
-        cursor.execute("SELECT dwell_time FROM ranking_feedback WHERE memory_id = 42")
-        row = cursor.fetchone()
-        conn.close()
-        assert row is not None
-        assert abs(row[0] - 15.3) < 0.01
-
-    def test_empty_query_returns_none(self, collector):
-        result = collector.record_dashboard_click(42, "")
-        assert result is None
-
-
-# ---------------------------------------------------------------------------
-# Query Hashing
-# ---------------------------------------------------------------------------
-
-class TestHashQuery:
-    def test_deterministic(self, collector):
-        h1 = collector._hash_query("deploy fastapi")
-        h2 = collector._hash_query("deploy fastapi")
-        assert h1 == h2
-
-    def test_sha256_first_16(self, collector):
-        query = "deploy fastapi"
-        expected = hashlib.sha256(query.encode("utf-8")).hexdigest()[:16]
-        assert collector._hash_query(query) == expected
-
-    def test_length_is_16(self, collector):
-        result = collector._hash_query("any string")
-        assert len(result) == 16
-
-    def test_different_queries_different_hashes(self, collector):
-        h1 = collector._hash_query("query one")
-        h2 = collector._hash_query("query two")
-        assert h1 != h2
-
-
-# ---------------------------------------------------------------------------
-# Keyword Extraction
-# ---------------------------------------------------------------------------
-
-class TestExtractKeywords:
-    def test_stopword_removal(self, collector):
-        kw = collector._extract_keywords("how to deploy the app")
-        assert "how" not in kw
-        assert "to" not in kw
-        assert "the" not in kw
-        assert "deploy" in kw
-
-    def test_top_n_limit(self, collector):
-        kw = collector._extract_keywords(
-            "python fastapi docker kubernetes deployment pipeline"
-        )
-        assert len(kw.split(",")) <= 3
-
-    def test_empty_query(self, collector):
-        assert collector._extract_keywords("") == ""
-
-    def test_only_stopwords(self, collector):
-        assert collector._extract_keywords("the and or but") == ""
-
-    def test_comma_separated_output(self, collector):
-        kw = collector._extract_keywords("deploy fastapi docker")
-        assert "," in kw or len(kw.split(",")) == 1  # single keyword = no comma
-
-
-# ---------------------------------------------------------------------------
-# Passive Decay
-# ---------------------------------------------------------------------------
-
-class TestPassiveDecay:
-    def test_record_recall_results(self, collector):
-        collector.record_recall_results("test query", [1, 2, 3])
-        assert collector._recall_count == 1
-
-    def test_compute_passive_decay_below_threshold(self, collector):
-        """Should return 0 if below threshold."""
-        collector.record_recall_results("test query", [1, 2, 3])
-        result = collector.compute_passive_decay(threshold=10)
-        assert result == 0
-
-    def test_compute_passive_decay_with_candidates(self, collector, learning_db):
-        """Memory appearing in 5+ distinct queries should get decay signal."""
-        # Create 10+ recall operations with memory_id=99 appearing in 6 distinct queries
-        for i in range(10):
-            collector.record_recall_results(f"query_{i}", [99, 100 + i])
-
-        decay_count = collector.compute_passive_decay(threshold=10)
-        # memory 99 appeared in 10 distinct queries, no positive feedback
-        assert decay_count >= 1
-
-    def test_no_decay_for_positively_rated(self, collector, learning_db):
-        """Memories with positive feedback should NOT get passive decay."""
-        # Give memory 99 positive feedback first
-        learning_db.store_feedback(
-            query_hash="q", memory_id=99, signal_type="mcp_used",
-            signal_value=1.0, channel="mcp",
-        )
-
-        # Record 10+ recall operations with memory 99
-        for i in range(12):
-            collector.record_recall_results(f"query_{i}", [99])
-
-        decay_count = collector.compute_passive_decay(threshold=10)
-        assert decay_count == 0
-
-    def test_buffer_cleared_after_decay(self, collector):
-        """Recall buffer should be cleared after computing decay."""
-        for i in range(10):
-            collector.record_recall_results(f"q{i}", [1])
-        collector.compute_passive_decay(threshold=10)
-        assert collector._recall_count == 0
-
-    def test_empty_query_ignored(self, collector):
-        collector.record_recall_results("", [1, 2, 3])
-        assert collector._recall_count == 0
-
-    def test_empty_ids_ignored(self, collector):
-        collector.record_recall_results("test query", [])
-        assert collector._recall_count == 0
-
-
-# ---------------------------------------------------------------------------
-# Summary
-# ---------------------------------------------------------------------------
-
-class TestFeedbackSummary:
-    def test_summary_with_data(self, collector, learning_db):
-        collector.record_memory_used(1, "q1", usefulness="high")
-        collector.record_cli_useful([2], "q2")
-        collector.record_dashboard_click(3, "q3")
-
-        summary = collector.get_feedback_summary()
-        assert summary["total_signals"] == 3
-        assert summary["unique_queries"] == 3
-        assert "mcp" in summary["by_channel"]
-        assert "cli" in summary["by_channel"]
-        assert "dashboard" in summary["by_channel"]
-
-    def test_summary_empty_db(self, collector):
-        summary = collector.get_feedback_summary()
-        assert summary["total_signals"] == 0
-        assert summary["unique_queries"] == 0
-
-    def test_summary_no_db_auto_creates(self, collector_no_db):
-        """v2.7.2+: Auto-created DB returns valid summary, not error."""
-        summary = collector_no_db.get_feedback_summary()
-        assert "total_signals" in summary
-
-    def test_summary_buffer_stats(self, collector):
-        collector.record_recall_results("q1", [1, 2, 3])
-        collector.record_recall_results("q2", [1, 4, 5])
-
-        summary = collector.get_feedback_summary()
-        assert summary["recall_buffer_size"] == 2