superlocalmemory 2.8.5 → 3.0.0

package/src/learning/tests/test_learning_db_v28.py

@@ -1,110 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for v2.8 learning.db schema extensions — outcome and behavioral tables.
-"""
-import pytest
-import json
-import sys
-import os
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-@pytest.fixture(autouse=True)
-def reset_singleton():
-    from learning.learning_db import LearningDB
-    LearningDB.reset_instance()
-    yield
-    LearningDB.reset_instance()
-
-
-@pytest.fixture
-def learning_db(tmp_path):
-    from learning.learning_db import LearningDB
-    db_path = tmp_path / "learning.db"
-    return LearningDB(db_path=db_path)
-
-
-class TestActionOutcomesTable:
-    def test_table_exists(self, learning_db):
-        conn = learning_db._get_connection()
-        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
-        conn.close()
-        assert "action_outcomes" in tables
-
-    def test_store_outcome(self, learning_db):
-        oid = learning_db.store_outcome([1, 2], "success", action_type="code_written", project="myproject")
-        assert isinstance(oid, int)
-        assert oid > 0
-
-    def test_get_outcomes(self, learning_db):
-        learning_db.store_outcome([1], "success", project="proj1")
-        learning_db.store_outcome([2], "failure", project="proj1")
-        results = learning_db.get_outcomes(project="proj1")
-        assert len(results) == 2
-
-    def test_get_outcomes_by_memory_id(self, learning_db):
-        learning_db.store_outcome([1, 2], "success")
-        learning_db.store_outcome([3], "failure")
-        results = learning_db.get_outcomes(memory_id=1)
-        assert len(results) == 1
-        assert 1 in results[0]["memory_ids"]
-
-    def test_outcome_has_profile(self, learning_db):
-        learning_db.store_outcome([1], "success")
-        results = learning_db.get_outcomes()
-        assert results[0]["profile"] == "default"
-
-
-class TestBehavioralPatternsTable:
-    def test_table_exists(self, learning_db):
-        conn = learning_db._get_connection()
-        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
-        conn.close()
-        assert "behavioral_patterns" in tables
-
-    def test_store_pattern(self, learning_db):
-        pid = learning_db.store_behavioral_pattern("tag_success", "python", success_rate=0.85, evidence_count=10, confidence=0.8)
-        assert isinstance(pid, int)
-
-    def test_get_patterns(self, learning_db):
-        learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
-        learning_db.store_behavioral_pattern("tag_success", "javascript", confidence=0.6)
-        results = learning_db.get_behavioral_patterns(pattern_type="tag_success")
-        assert len(results) == 2
-
-    def test_get_patterns_min_confidence(self, learning_db):
-        learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
-        learning_db.store_behavioral_pattern("tag_success", "javascript", confidence=0.3)
-        results = learning_db.get_behavioral_patterns(min_confidence=0.5)
-        assert len(results) == 1
-        assert results[0]["pattern_key"] == "python"
-
-
-class TestCrossProjectTable:
-    def test_table_exists(self, learning_db):
-        conn = learning_db._get_connection()
-        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
-        conn.close()
-        assert "cross_project_behaviors" in tables
-
-    def test_store_transfer(self, learning_db):
-        pid = learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
-        tid = learning_db.store_cross_project("project_a", "project_b", pid, confidence=0.7)
-        assert isinstance(tid, int)
-
-    def test_get_transfers(self, learning_db):
-        pid = learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
-        learning_db.store_cross_project("proj_a", "proj_b", pid, confidence=0.7)
-        results = learning_db.get_cross_project_transfers(source_project="proj_a")
-        assert len(results) == 1
-        assert results[0]["target_project"] == "proj_b"
-
-    def test_existing_tables_untouched(self, learning_db):
-        """Existing 6 tables should still exist."""
-        conn = learning_db._get_connection()
-        tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
-        conn.close()
-        for expected in ["transferable_patterns", "workflow_patterns", "ranking_feedback", "ranking_models", "source_quality", "engagement_metrics"]:
-            assert expected in tables

package/src/learning/tests/test_learning_init_v28.py

@@ -1,48 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for unified learning status with v2.8 engines.
-"""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestUnifiedLearningStatus:
-    def test_get_status_has_v28_engines(self):
-        """Status should include lifecycle, behavioral, compliance info."""
-        from learning import get_status
-        status = get_status()
-        assert "v28_engines" in status
-
-    def test_v28_engines_structure(self):
-        from learning import get_status
-        status = get_status()
-        engines = status["v28_engines"]
-        assert "lifecycle" in engines
-        assert "behavioral" in engines
-        assert "compliance" in engines
-
-    def test_lifecycle_status_included(self):
-        from learning import get_status
-        status = get_status()
-        lifecycle = status["v28_engines"]["lifecycle"]
-        assert "available" in lifecycle
-
-    def test_behavioral_status_included(self):
-        from learning import get_status
-        status = get_status()
-        behavioral = status["v28_engines"]["behavioral"]
-        assert "available" in behavioral
-
-    def test_compliance_status_included(self):
-        from learning import get_status
-        status = get_status()
-        compliance = status["v28_engines"]["compliance"]
-        assert "available" in compliance
-
-    def test_graceful_when_engines_unavailable(self):
-        """Status should not crash even if engine imports fail."""
-        from learning import get_status
-        status = get_status()
-        # Should always return a dict with v28_engines
-        assert isinstance(status["v28_engines"], dict)

package/src/learning/tests/test_outcome_signals.py

@@ -1,48 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for v2.8 outcome signal types in feedback collector.
-"""
-import pytest
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestOutcomeSignalTypes:
-    """Verify outcome signal types are registered and have correct values."""
-
-    def test_outcome_success_registered(self):
-        from learning.feedback_collector import FeedbackCollector
-        assert "outcome_success" in FeedbackCollector.SIGNAL_VALUES
-        assert FeedbackCollector.SIGNAL_VALUES["outcome_success"] == 1.0
-
-    def test_outcome_partial_registered(self):
-        from learning.feedback_collector import FeedbackCollector
-        assert "outcome_partial" in FeedbackCollector.SIGNAL_VALUES
-        assert FeedbackCollector.SIGNAL_VALUES["outcome_partial"] == 0.5
-
-    def test_outcome_failure_registered(self):
-        from learning.feedback_collector import FeedbackCollector
-        assert "outcome_failure" in FeedbackCollector.SIGNAL_VALUES
-        assert FeedbackCollector.SIGNAL_VALUES["outcome_failure"] == 0.0
-
-    def test_outcome_retry_registered(self):
-        from learning.feedback_collector import FeedbackCollector
-        assert "outcome_retry" in FeedbackCollector.SIGNAL_VALUES
-        assert FeedbackCollector.SIGNAL_VALUES["outcome_retry"] == 0.2
-
-    def test_existing_signals_unchanged(self):
-        """All 17 original signal types still present with correct values."""
-        from learning.feedback_collector import FeedbackCollector
-        SV = FeedbackCollector.SIGNAL_VALUES
-        assert SV["mcp_used_high"] == 1.0
-        assert SV["dashboard_thumbs_up"] == 1.0
-        assert SV["implicit_positive_timegap"] == 0.6
-        assert SV["passive_decay"] == 0.0
-        assert len(SV) == 21  # 17 original + 4 new
-
-    def test_total_signal_count(self):
-        """Should have exactly 21 signal types (17 + 4)."""
-        from learning.feedback_collector import FeedbackCollector
-        assert len(FeedbackCollector.SIGNAL_VALUES) == 21

package/src/learning/tests/test_project_context.py

@@ -1,292 +0,0 @@
-#!/usr/bin/env python3
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-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