superlocalmemory 2.6.5 → 2.7.0

package/src/learning/tests/test_project_context.py

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Tests for ProjectContextManager (v2.7)
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+"""
+
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def memory_db(tmp_path):
+    """Create a minimal memory.db with the required schema."""
+    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
+
+
+@pytest.fixture
+def pcm(memory_db):
+    from src.learning.project_context_manager import ProjectContextManager
+    return ProjectContextManager(memory_db_path=memory_db)
+
+
+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, project_name, project_path,
+                                  profile, cluster_id, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+        ''', (
+            m.get('content', 'test'),
+            m.get('project_name'),
+            m.get('project_path'),
+            m.get('profile', 'default'),
+            m.get('cluster_id'),
+            m.get('created_at', '2026-02-16 10:00:00'),
+        ))
+    conn.commit()
+    conn.close()
+
+
+# ---------------------------------------------------------------------------
+# Path Extraction
+# ---------------------------------------------------------------------------
+
+class TestExtractProjectFromPath:
+    """Test the static _extract_project_from_path method."""
+
+    def test_projects_parent(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/Users/varun/projects/MY_PROJECT/src/main.py"
+        )
+        assert result == "MY_PROJECT"
+
+    def test_repos_parent(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/home/dev/repos/my-app/lib/util.js"
+        )
+        assert result == "my-app"
+
+    def test_documents_parent(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/Users/varun/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src/learning/foo.py"
+        )
+        assert result == "SuperLocalMemoryV2-repo"
+
+    def test_workspace_services(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/workspace/services/auth-service/index.ts"
+        )
+        assert result == "auth-service"
+
+    def test_empty_path(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        assert ProjectContextManager._extract_project_from_path("") is None
+
+    def test_none_path(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        assert ProjectContextManager._extract_project_from_path(None) is None
+
+    def test_short_path(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        assert ProjectContextManager._extract_project_from_path("/") is None
+
+    def test_github_parent(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/home/user/github/cool-project/README.md"
+        )
+        assert result == "cool-project"
+
+    def test_skip_dirs_not_returned(self):
+        """Directories like src, lib, node_modules should not be project names."""
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/Users/dev/projects/myapp/src/lib/util.py"
+        )
+        assert result == "myapp"
+
+    def test_code_parent(self):
+        from src.learning.project_context_manager import ProjectContextManager
+        result = ProjectContextManager._extract_project_from_path(
+            "/Users/dev/code/awesome-tool/main.py"
+        )
+        assert result == "awesome-tool"
+
+
+# ---------------------------------------------------------------------------
+# Project Detection
+# ---------------------------------------------------------------------------
+
+class TestDetectCurrentProject:
+    def test_with_explicit_project_tags(self, pcm, memory_db):
+        """Signal 1: project_name tag should dominate."""
+        memories = [
+            {"content": "test", "project_name": "MyProject"},
+            {"content": "test", "project_name": "MyProject"},
+            {"content": "test", "project_name": "MyProject"},
+        ]
+        recent = [
+            {"project_name": "MyProject", "project_path": None, "cluster_id": None,
+             "profile": "default", "content": "test"}
+            for _ in range(3)
+        ]
+        result = pcm.detect_current_project(recent_memories=recent)
+        assert result == "MyProject"
+
+    def test_with_project_paths(self, pcm):
+        """Signal 2: project_path analysis."""
+        recent = [
+            {"project_name": None,
+             "project_path": "/Users/dev/projects/SLM/src/main.py",
+             "cluster_id": None, "profile": "default", "content": "test"}
+            for _ in range(5)
+        ]
+        result = pcm.detect_current_project(recent_memories=recent)
+        assert result == "SLM"
+
+    def test_with_profiles(self, pcm):
+        """Signal 3: active profile as weak signal."""
+        recent = [
+            {"project_name": None, "project_path": None,
+             "cluster_id": None, "profile": "work", "content": "test"}
+        ]
+        # Profile is weak (weight=1), may not win alone due to 40% threshold
+        # with just 1 memory. But adding it to existing signal helps.
+        recent_with_name = [
+            {"project_name": "work", "project_path": None,
+             "cluster_id": None, "profile": "work", "content": "test"}
+        ]
+        result = pcm.detect_current_project(recent_memories=recent_with_name)
+        assert result == "work"
+
+    def test_empty_memories(self, pcm):
+        result = pcm.detect_current_project(recent_memories=[])
+        assert result is None
+
+    def test_ambiguous_results_none(self, pcm):
+        """When no project clears 40% threshold, return None."""
+        recent = [
+            {"project_name": "A", "project_path": None, "cluster_id": None,
+             "profile": "default", "content": "test"},
+            {"project_name": "B", "project_path": None, "cluster_id": None,
+             "profile": "default", "content": "test"},
+            {"project_name": "C", "project_path": None, "cluster_id": None,
+             "profile": "default", "content": "test"},
+        ]
+        # Each gets 3 points (weight 3 for project_tag), total = 9
+        # 3/9 = 33% < 40% threshold, so None
+        result = pcm.detect_current_project(recent_memories=recent)
+        assert result is None
+
+    def test_mixed_signals(self, pcm):
+        """Both project_name and project_path pointing to same project."""
+        recent = [
+            {"project_name": "SLM", "project_path": "/projects/SLM/src/a.py",
+             "cluster_id": None, "profile": "default", "content": "test"},
+            {"project_name": "SLM", "project_path": "/projects/SLM/src/b.py",
+             "cluster_id": None, "profile": "default", "content": "test"},
+        ]
+        result = pcm.detect_current_project(recent_memories=recent)
+        assert result == "SLM"
+
+
+# ---------------------------------------------------------------------------
+# Project Boost
+# ---------------------------------------------------------------------------
+
+class TestGetProjectBoost:
+    def test_match_returns_1_0(self, pcm):
+        memory = {"project_name": "MyProject"}
+        assert pcm.get_project_boost(memory, "MyProject") == 1.0
+
+    def test_case_insensitive_match(self, pcm):
+        memory = {"project_name": "myproject"}
+        assert pcm.get_project_boost(memory, "MyProject") == 1.0
+
+    def test_mismatch_returns_0_3(self, pcm):
+        memory = {"project_name": "OtherProject"}
+        assert pcm.get_project_boost(memory, "MyProject") == 0.3
+
+    def test_no_current_project_returns_0_6(self, pcm):
+        memory = {"project_name": "Anything"}
+        assert pcm.get_project_boost(memory, None) == 0.6
+
+    def test_no_project_info_returns_0_6(self, pcm):
+        memory = {"content": "no project info"}
+        assert pcm.get_project_boost(memory, "MyProject") == 0.6
+
+    def test_path_match(self, pcm):
+        memory = {"project_path": "/projects/SLM/src/main.py"}
+        assert pcm.get_project_boost(memory, "SLM") == 1.0
+
+    def test_path_mismatch(self, pcm):
+        memory = {"project_path": "/projects/OTHER/src/main.py"}
+        assert pcm.get_project_boost(memory, "SLM") == 0.3
+
+
+# ---------------------------------------------------------------------------
+# safe_get
+# ---------------------------------------------------------------------------
+
+class TestSafeGet:
+    def test_normal_value(self, pcm):
+        assert pcm._safe_get({"key": "value"}, "key") == "value"
+
+    def test_missing_key(self, pcm):
+        assert pcm._safe_get({"key": "value"}, "other") is None
+
+    def test_none_value(self, pcm):
+        assert pcm._safe_get({"key": None}, "key") is None
+
+    def test_empty_string(self, pcm):
+        assert pcm._safe_get({"key": ""}, "key") is None
+
+    def test_whitespace_string(self, pcm):
+        assert pcm._safe_get({"key": "   "}, "key") is None
+
+    def test_integer_value(self, pcm):
+        assert pcm._safe_get({"key": 42}, "key") == 42
+
+
+# ---------------------------------------------------------------------------
+# Cache Invalidation
+# ---------------------------------------------------------------------------
+
+class TestCacheInvalidation:
+    def test_invalidate_cache(self, pcm):
+        # Force column cache to be populated
+        pcm._get_available_columns()
+        assert pcm._available_columns is not None
+
+        pcm.invalidate_cache()
+        assert pcm._available_columns is None

package/src/learning/tests/test_source_quality.py

@@ -0,0 +1,355 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Tests for SourceQualityScorer (v2.7)
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+"""
+
+import sqlite3
+from pathlib import Path
+
+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 created_by column."""
+    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, created_by, source_protocol)
+            VALUES (?, ?, ?)
+        ''', (
+            m.get('content', 'test'),
+            m.get('created_by'),
+            m.get('source_protocol'),
+        ))
+    conn.commit()
+    conn.close()
+
+
+@pytest.fixture
+def scorer(memory_db, learning_db):
+    from src.learning.source_quality_scorer import SourceQualityScorer
+    return SourceQualityScorer(
+        memory_db_path=memory_db,
+        learning_db=learning_db,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Beta-Binomial Calculation
+# ---------------------------------------------------------------------------
+
+class TestBetaBinomialScore:
+    def test_zero_data(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # (1 + 0) / (2 + 0) = 0.5
+        assert abs(SourceQualityScorer._beta_binomial_score(0, 0) - 0.5) < 0.001
+
+    def test_perfect_score(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # (1 + 10) / (2 + 10) = 11/12 ~ 0.917
+        score = SourceQualityScorer._beta_binomial_score(10, 10)
+        assert abs(score - 11.0 / 12.0) < 0.001
+
+    def test_poor_score(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # (1 + 1) / (2 + 10) = 2/12 ~ 0.167
+        score = SourceQualityScorer._beta_binomial_score(1, 10)
+        assert abs(score - 2.0 / 12.0) < 0.001
+
+    def test_even_split(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # (1 + 5) / (2 + 10) = 6/12 = 0.5
+        score = SourceQualityScorer._beta_binomial_score(5, 10)
+        assert abs(score - 0.5) < 0.001
+
+    def test_large_numbers_convergence(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # (1 + 80) / (2 + 100) = 81/102 ~ 0.794
+        score = SourceQualityScorer._beta_binomial_score(80, 100)
+        assert abs(score - 81.0 / 102.0) < 0.001
+
+    def test_score_bounded(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        # Should always be in [0.0, 1.0]
+        for pos, total in [(0, 0), (100, 100), (0, 100), (100, 0)]:
+            score = SourceQualityScorer._beta_binomial_score(pos, total)
+            assert 0.0 <= score <= 1.0, f"pos={pos}, total={total}, score={score}"
+
+
+# ---------------------------------------------------------------------------
+# compute_source_scores
+# ---------------------------------------------------------------------------
+
+class TestComputeSourceScores:
+    def test_empty_db(self, scorer):
+        scores = scorer.compute_source_scores()
+        assert scores == {}
+
+    def test_with_memories(self, scorer, memory_db, learning_db):
+        """Sources with memories should get computed scores."""
+        _insert_memories(memory_db, [
+            {"content": "test 1", "created_by": "mcp:claude"},
+            {"content": "test 2", "created_by": "mcp:claude"},
+            {"content": "test 3", "created_by": "mcp:cursor"},
+            {"content": "test 4", "created_by": "cli:terminal"},
+        ])
+        scores = scorer.compute_source_scores()
+        assert len(scores) >= 3
+        assert "mcp:claude" in scores
+        assert "mcp:cursor" in scores
+        assert "cli:terminal" in scores
+
+    def test_with_positive_feedback(self, scorer, memory_db, learning_db):
+        """Sources with positive feedback should get higher scores."""
+        _insert_memories(memory_db, [
+            {"content": "test 1", "created_by": "good_source"},
+            {"content": "test 2", "created_by": "good_source"},
+            {"content": "test 3", "created_by": "bad_source"},
+            {"content": "test 4", "created_by": "bad_source"},
+        ])
+
+        # Add positive feedback for good_source memories (id 1, 2)
+        learning_db.store_feedback(
+            query_hash="q1", memory_id=1,
+            signal_type="mcp_used", signal_value=1.0, channel="mcp",
+        )
+        learning_db.store_feedback(
+            query_hash="q2", memory_id=2,
+            signal_type="mcp_used", signal_value=1.0, channel="mcp",
+        )
+
+        scores = scorer.compute_source_scores()
+        assert scores["good_source"] > scores["bad_source"]
+
+    def test_stores_in_learning_db(self, scorer, memory_db, learning_db):
+        """Computed scores should be persisted in learning.db."""
+        _insert_memories(memory_db, [
+            {"content": "test", "created_by": "mcp:test"},
+        ])
+        scorer.compute_source_scores()
+
+        db_scores = learning_db.get_source_scores()
+        assert "mcp:test" in db_scores
+
+    def test_no_created_by_column(self, tmp_path, learning_db):
+        """Memory DB without created_by should group all as 'unknown'."""
+        db_path = tmp_path / "old_memory.db"
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute('''
+            CREATE TABLE memories (
+                id INTEGER PRIMARY KEY, content TEXT
+            )
+        ''')
+        cursor.execute("INSERT INTO memories (content) VALUES ('test')")
+        conn.commit()
+        conn.close()
+
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        s = SourceQualityScorer(memory_db_path=db_path, learning_db=learning_db)
+        scores = s.compute_source_scores()
+        assert "unknown" in scores
+
+
+# ---------------------------------------------------------------------------
+# get_source_boost
+# ---------------------------------------------------------------------------
+
+class TestGetSourceBoost:
+    def test_known_source(self, scorer):
+        """Known source from cache should return its score."""
+        scorer._cached_scores = {"mcp:claude": 0.8, "cli:terminal": 0.4}
+
+        memory = {"created_by": "mcp:claude"}
+        assert scorer.get_source_boost(memory) == 0.8
+
+    def test_unknown_source_returns_default(self, scorer):
+        """Unknown source should return DEFAULT_QUALITY_SCORE (0.5)."""
+        from src.learning.source_quality_scorer import DEFAULT_QUALITY_SCORE
+        scorer._cached_scores = {"mcp:claude": 0.8}
+
+        memory = {"created_by": "unknown_tool"}
+        assert scorer.get_source_boost(memory) == DEFAULT_QUALITY_SCORE
+
+    def test_no_source_info(self, scorer):
+        """Memory with no created_by should return default."""
+        from src.learning.source_quality_scorer import DEFAULT_QUALITY_SCORE
+        memory = {"content": "no source info"}
+        assert scorer.get_source_boost(memory) == DEFAULT_QUALITY_SCORE
+
+    def test_explicit_scores_override_cache(self, scorer):
+        """Passing source_scores directly should override cache."""
+        scorer._cached_scores = {"mcp:claude": 0.8}
+        override = {"mcp:claude": 0.3}
+
+        memory = {"created_by": "mcp:claude"}
+        assert scorer.get_source_boost(memory, source_scores=override) == 0.3
+
+    def test_source_protocol_fallback(self, scorer):
+        """If created_by is None, fall back to source_protocol."""
+        scorer._cached_scores = {"mcp": 0.7}
+        memory = {"created_by": None, "source_protocol": "mcp"}
+        assert scorer.get_source_boost(memory) == 0.7
+
+    def test_user_source(self, scorer):
+        """created_by='user' is the default from provenance_tracker."""
+        scorer._cached_scores = {"user": 0.6}
+        memory = {"created_by": "user"}
+        assert scorer.get_source_boost(memory) == 0.6
+
+
+# ---------------------------------------------------------------------------
+# extract_source_id
+# ---------------------------------------------------------------------------
+
+class TestExtractSourceId:
+    def test_created_by_primary(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        memory = {"created_by": "mcp:claude-desktop", "source_protocol": "mcp"}
+        assert SourceQualityScorer._extract_source_id(memory) == "mcp:claude-desktop"
+
+    def test_source_protocol_fallback(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        memory = {"created_by": None, "source_protocol": "cli"}
+        assert SourceQualityScorer._extract_source_id(memory) == "cli"
+
+    def test_user_default(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        memory = {"created_by": "user"}
+        assert SourceQualityScorer._extract_source_id(memory) == "user"
+
+    def test_no_source_returns_none(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        memory = {"content": "no source info"}
+        assert SourceQualityScorer._extract_source_id(memory) is None
+
+    def test_empty_created_by(self):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        memory = {"created_by": ""}
+        # Empty string should fall through to source_protocol
+        result = SourceQualityScorer._extract_source_id(memory)
+        assert result is None
+
+
+# ---------------------------------------------------------------------------
+# Refresh & Summary
+# ---------------------------------------------------------------------------
+
+class TestRefreshAndSummary:
+    def test_refresh(self, scorer, memory_db):
+        _insert_memories(memory_db, [
+            {"content": "test", "created_by": "mcp:test"},
+        ])
+        scores = scorer.refresh()
+        assert isinstance(scores, dict)
+
+    def test_get_source_summary_empty(self, scorer):
+        summary = scorer.get_source_summary()
+        assert "No source quality data" in summary
+
+    def test_get_source_summary_with_data(self, scorer, memory_db, learning_db):
+        _insert_memories(memory_db, [
+            {"content": "test", "created_by": "mcp:claude"},
+        ])
+        scorer.compute_source_scores()
+        summary = scorer.get_source_summary()
+        assert "mcp:claude" in summary
+
+    def test_get_all_scores_empty(self, scorer):
+        all_scores = scorer.get_all_scores()
+        assert all_scores == {}
+
+    def test_get_all_scores_with_data(self, scorer, memory_db, learning_db):
+        _insert_memories(memory_db, [
+            {"content": "test", "created_by": "mcp:test"},
+        ])
+        scorer.compute_source_scores()
+        all_scores = scorer.get_all_scores()
+        assert "mcp:test" in all_scores
+        assert "quality_score" in all_scores["mcp:test"]
+        assert "positive_signals" in all_scores["mcp:test"]
+        assert "total_memories" in all_scores["mcp:test"]
+
+
+# ---------------------------------------------------------------------------
+# No Learning DB
+# ---------------------------------------------------------------------------
+
+class TestNoLearningDb:
+    def test_scorer_without_learning_db(self, memory_db):
+        from src.learning.source_quality_scorer import SourceQualityScorer
+        scorer = SourceQualityScorer(
+            memory_db_path=memory_db,
+            learning_db=None,
+        )
+        # Should not crash
+        scores = scorer.compute_source_scores()
+        assert isinstance(scores, dict)
+
+    def test_boost_without_cache(self, memory_db):
+        from src.learning.source_quality_scorer import (
+            SourceQualityScorer, DEFAULT_QUALITY_SCORE,
+        )
+        scorer = SourceQualityScorer(
+            memory_db_path=memory_db,
+            learning_db=None,
+        )
+        memory = {"created_by": "mcp:anything"}
+        assert scorer.get_source_boost(memory) == DEFAULT_QUALITY_SCORE