superlocalmemory 2.6.5 → 2.7.1

package/src/learning/tests/test_workflow_miner.py

@@ -0,0 +1,322 @@
+#!/usr/bin/env python3
+"""
+SuperLocalMemory V2 - Tests for WorkflowPatternMiner (v2.7)
+Copyright (c) 2026 Varun Pratap Bhardwaj
+Licensed under MIT License
+"""
+
+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 miner(learning_db):
+    from src.learning.workflow_pattern_miner import WorkflowPatternMiner
+    return WorkflowPatternMiner(learning_db=learning_db)
+
+
+@pytest.fixture
+def miner_no_db():
+    from src.learning.workflow_pattern_miner import WorkflowPatternMiner
+    return WorkflowPatternMiner(learning_db=None)
+
+
+# ---------------------------------------------------------------------------
+# Activity Classification
+# ---------------------------------------------------------------------------
+
+class TestClassifyActivity:
+    """Test _classify_activity for all 7 types + unknown."""
+
+    def test_docs(self, miner):
+        assert miner._classify_activity("Updated the documentation for API") == "docs"
+        assert miner._classify_activity("Added README and wiki pages") == "docs"
+
+    def test_architecture(self, miner):
+        assert miner._classify_activity("Designed the system architecture") == "architecture"
+        assert miner._classify_activity("Created ERD for data model") == "architecture"
+
+    def test_code(self, miner):
+        assert miner._classify_activity("Implemented the new function for parsing") == "code"
+        assert miner._classify_activity("Refactored the module structure") == "code"
+
+    def test_test(self, miner):
+        assert miner._classify_activity("Added pytest fixtures and assertions") == "test"
+        assert miner._classify_activity("Wrote unit test for the parser") == "test"
+
+    def test_debug(self, miner):
+        assert miner._classify_activity("Fixed the bug in authentication") == "debug"
+        assert miner._classify_activity("Analyzed error traceback in production") == "debug"
+
+    def test_deploy(self, miner):
+        assert miner._classify_activity("Deployed via Docker to production") == "deploy"
+        assert miner._classify_activity("Updated the CI/CD pipeline") == "deploy"
+
+    def test_config(self, miner):
+        assert miner._classify_activity("Updated config settings and env variables") == "config"
+        assert miner._classify_activity("Added package dependency to requirements") == "config"
+
+    def test_unknown(self, miner):
+        assert miner._classify_activity("Had a meeting about the roadmap") == "unknown"
+        assert miner._classify_activity("") == "unknown"
+        assert miner._classify_activity("random unrelated text") == "unknown"
+
+    def test_word_boundary_matching(self, miner):
+        """'test' should match 'test' but not 'latest'."""
+        assert miner._classify_activity("ran the test suite") == "test"
+        # "latest" contains "test" but word boundary prevents match
+        # However, 'release' is a deploy keyword
+        result = miner._classify_activity("checked the latest version of release")
+        assert result == "deploy"  # 'release' is deploy keyword
+
+
+# ---------------------------------------------------------------------------
+# Hour to Bucket Mapping
+# ---------------------------------------------------------------------------
+
+class TestHourToBucket:
+    def test_night_hours(self, miner):
+        for hour in [0, 1, 2, 3, 4, 5]:
+            assert miner._hour_to_bucket(hour) == "night", f"hour={hour}"
+
+    def test_morning_hours(self, miner):
+        for hour in [6, 7, 8, 9, 10, 11]:
+            assert miner._hour_to_bucket(hour) == "morning", f"hour={hour}"
+
+    def test_afternoon_hours(self, miner):
+        for hour in [12, 13, 14, 15, 16, 17]:
+            assert miner._hour_to_bucket(hour) == "afternoon", f"hour={hour}"
+
+    def test_evening_hours(self, miner):
+        for hour in [18, 19, 20, 21, 22, 23]:
+            assert miner._hour_to_bucket(hour) == "evening", f"hour={hour}"
+
+    def test_boundary_cases(self, miner):
+        assert miner._hour_to_bucket(0) == "night"
+        assert miner._hour_to_bucket(5) == "night"
+        assert miner._hour_to_bucket(6) == "morning"
+        assert miner._hour_to_bucket(11) == "morning"
+        assert miner._hour_to_bucket(12) == "afternoon"
+        assert miner._hour_to_bucket(17) == "afternoon"
+        assert miner._hour_to_bucket(18) == "evening"
+        assert miner._hour_to_bucket(23) == "evening"
+
+
+# ---------------------------------------------------------------------------
+# Sequence Mining
+# ---------------------------------------------------------------------------
+
+class TestMineSequences:
+    def test_basic_sequence(self, miner):
+        """A repeating pattern should be detected."""
+        memories = []
+        # Repeat: docs -> code -> test, 5 times
+        activity_words = {
+            "docs": "Updated the documentation",
+            "code": "Implemented new feature function",
+            "test": "Added pytest coverage",
+        }
+        for _ in range(5):
+            for act in ["docs", "code", "test"]:
+                memories.append({
+                    "content": activity_words[act],
+                    "created_at": "2026-02-16 10:00:00",
+                })
+
+        results = miner.mine_sequences(memories=memories, min_support=0.1)
+        assert len(results) > 0
+        # The docs->code->test pattern should appear
+        sequences_as_tuples = [tuple(r["sequence"]) for r in results]
+        assert ("docs", "code") in sequences_as_tuples or \
+               ("code", "test") in sequences_as_tuples or \
+               ("docs", "code", "test") in sequences_as_tuples
+
+    def test_min_support_filter(self, miner):
+        """High min_support should filter out rare 2-gram patterns.
+
+        With 4 distinct activities (docs, code, deploy, debug), each 2-gram
+        has support 1/3 ~ 0.33. Setting min_support=0.5 should exclude them.
+        Note: longer n-grams (4-gram) may have support=1.0 because there is
+        only 1 window of that length, so we specifically check 2-grams.
+        """
+        memories = [
+            {"content": "Updated documentation", "created_at": "2026-02-16 10:00:00"},
+            {"content": "Implemented function code", "created_at": "2026-02-16 11:00:00"},
+            {"content": "Deployed to production", "created_at": "2026-02-16 12:00:00"},
+            {"content": "Fixed the error bug", "created_at": "2026-02-16 13:00:00"},
+        ]
+        results = miner.mine_sequences(memories=memories, min_support=0.5)
+        # Filter results to only 2-grams (which cannot reach 0.5 support)
+        bigram_results = [r for r in results if r["length"] == 2]
+        assert len(bigram_results) == 0
+
+    def test_empty_memories(self, miner):
+        results = miner.mine_sequences(memories=[], min_support=0.1)
+        assert results == []
+
+    def test_single_memory(self, miner):
+        """Need at least 2 classified activities for sequence mining."""
+        memories = [{"content": "one code function", "created_at": "2026-02-16 10:00:00"}]
+        results = miner.mine_sequences(memories=memories, min_support=0.1)
+        assert results == []
+
+    def test_consecutive_identical_filtered(self, miner):
+        """N-grams with consecutive identical activities are filtered as noise."""
+        memories = [
+            {"content": "code function", "created_at": "2026-02-16 10:00:00"},
+            {"content": "code function", "created_at": "2026-02-16 11:00:00"},
+            {"content": "code function", "created_at": "2026-02-16 12:00:00"},
+        ]
+        results = miner.mine_sequences(memories=memories, min_support=0.1)
+        # All n-grams would be (code, code) or (code, code, code) -> filtered
+        assert len(results) == 0
+
+    def test_top_20_limit(self, miner):
+        """Results should be capped at 20."""
+        memories = []
+        types = ["docs", "code", "test", "debug", "deploy", "config"]
+        for i in range(100):
+            memories.append({
+                "content": f"Working on {types[i % len(types)]} implementation",
+                "created_at": f"2026-02-16 {i % 24:02d}:00:00",
+            })
+        results = miner.mine_sequences(memories=memories, min_support=0.01)
+        assert len(results) <= 20
+
+
+# ---------------------------------------------------------------------------
+# Temporal Pattern Mining
+# ---------------------------------------------------------------------------
+
+class TestMineTemporalPatterns:
+    def test_morning_coding(self, miner):
+        """Memories at morning hours with code content -> morning=code."""
+        memories = []
+        for hour in range(6, 12):
+            memories.append({
+                "content": "Implemented new function in the module",
+                "created_at": f"2026-02-16 {hour:02d}:30:00",
+            })
+        result = miner.mine_temporal_patterns(memories=memories)
+        assert "morning" in result
+        assert result["morning"]["dominant_activity"] == "code"
+        assert result["morning"]["evidence_count"] >= 5
+
+    def test_minimum_evidence_threshold(self, miner):
+        """Buckets with fewer than 5 evidence memories are omitted."""
+        memories = [
+            {"content": "Wrote code function", "created_at": "2026-02-16 09:00:00"},
+            {"content": "Wrote code class", "created_at": "2026-02-16 10:00:00"},
+        ]
+        result = miner.mine_temporal_patterns(memories=memories)
+        assert "morning" not in result  # Only 2 morning memories, need 5+
+
+    def test_time_bucketing(self, miner):
+        """Verify that memories are assigned to the correct time bucket."""
+        memories = []
+        # 6 evening test activities (18-23)
+        for i in range(6):
+            memories.append({
+                "content": f"Running pytest assertions {i}",
+                "created_at": f"2026-02-16 {20 + (i % 4):02d}:00:00",
+            })
+        result = miner.mine_temporal_patterns(memories=memories)
+        if "evening" in result:
+            assert result["evening"]["dominant_activity"] == "test"
+
+    def test_empty_memories(self, miner):
+        result = miner.mine_temporal_patterns(memories=[])
+        assert result == {}
+
+    def test_only_unknown_activities(self, miner):
+        """All unknown activities should produce empty result."""
+        memories = [
+            {"content": "random chat", "created_at": f"2026-02-16 {h:02d}:00:00"}
+            for h in range(6, 12)
+        ]
+        result = miner.mine_temporal_patterns(memories=memories)
+        assert "morning" not in result
+
+
+# ---------------------------------------------------------------------------
+# mine_all + persistence
+# ---------------------------------------------------------------------------
+
+class TestMineAll:
+    def test_mine_all_persists(self, miner, learning_db):
+        """mine_all should store patterns in learning_db."""
+        memories = []
+        for _ in range(3):
+            memories.extend([
+                {"content": "docs documentation wiki", "created_at": "2026-02-16 09:00:00"},
+                {"content": "code implement function", "created_at": "2026-02-16 10:00:00"},
+                {"content": "test pytest assertion", "created_at": "2026-02-16 11:00:00"},
+            ])
+
+        results = miner.mine_all(memories=memories)
+        assert "sequences" in results
+        assert "temporal" in results
+
+        # Check that patterns were stored
+        stored_seq = learning_db.get_workflow_patterns(pattern_type="sequence")
+        stored_temp = learning_db.get_workflow_patterns(pattern_type="temporal")
+        total_stored = len(stored_seq) + len(stored_temp)
+        assert total_stored >= 0  # At least attempted storage
+
+    def test_mine_all_no_db(self, miner_no_db):
+        """mine_all without DB should still return results, just not persist."""
+        memories = [
+            {"content": "docs documentation", "created_at": "2026-02-16 09:00:00"},
+            {"content": "code function", "created_at": "2026-02-16 10:00:00"},
+        ]
+        results = miner_no_db.mine_all(memories=memories)
+        assert "sequences" in results
+        assert "temporal" in results
+
+
+# ---------------------------------------------------------------------------
+# Parse Hour
+# ---------------------------------------------------------------------------
+
+class TestParseHour:
+    def test_iso_format(self, miner):
+        assert miner._parse_hour("2026-02-16T09:30:00") == 9
+
+    def test_sqlite_format(self, miner):
+        assert miner._parse_hour("2026-02-16 14:45:00") == 14
+
+    def test_with_microseconds(self, miner):
+        assert miner._parse_hour("2026-02-16 23:59:59.123456") == 23
+
+    def test_date_only_returns_none(self, miner):
+        # fromisoformat may or may not parse date-only; if it does, hour=0
+        result = miner._parse_hour("2026-02-16")
+        # Either None or 0 is acceptable
+        assert result is None or result == 0
+
+    def test_none_input(self, miner):
+        assert miner._parse_hour(None) is None
+
+    def test_empty_string(self, miner):
+        assert miner._parse_hour("") is None
+
+    def test_invalid_string(self, miner):
+        assert miner._parse_hour("not-a-timestamp") is None

package/ui/index.html

@@ -720,6 +720,11 @@
                     <i class="bi bi-clock-history"></i> Timeline
                 </button>
             </li>
+            <li class="nav-item">
+                <button class="nav-link" id="learning-tab" data-bs-toggle="tab" data-bs-target="#learning-pane">
+                    <i class="bi bi-mortarboard"></i> Learning <span class="badge bg-warning text-dark" style="font-size:0.6rem;vertical-align:top;">v2.7</span>
+                </button>
+            </li>
             <li class="nav-item">
                 <button class="nav-link" id="events-tab" data-bs-toggle="tab" data-bs-target="#events-pane">
                     <i class="bi bi-broadcast"></i> Live Events
@@ -906,6 +911,144 @@
                 </div>
             </div>
 
+            <!-- Learning System (v2.7) -->
+            <div class="tab-pane fade" id="learning-pane">
+                <!-- Ranking Phase & Engagement -->
+                <div class="row g-3 mb-3">
+                    <div class="col-md-4">
+                        <div class="card p-3 text-center">
+                            <div class="fw-bold text-muted small">RANKING PHASE</div>
+                            <div class="fs-3 fw-bold" id="learning-phase" style="color: var(--bs-primary);">--</div>
+                            <small class="text-muted" id="learning-phase-detail">Loading...</small>
+                        </div>
+                    </div>
+                    <div class="col-md-4">
+                        <div class="card p-3 text-center">
+                            <div class="fw-bold text-muted small">FEEDBACK SIGNALS</div>
+                            <div class="fs-3 fw-bold" id="learning-feedback-count">0</div>
+                            <small class="text-muted" id="learning-feedback-detail">0 unique queries</small>
+                        </div>
+                    </div>
+                    <div class="col-md-4">
+                        <div class="card p-3 text-center">
+                            <div class="fw-bold text-muted small">ENGAGEMENT HEALTH</div>
+                            <div class="fs-3 fw-bold" id="learning-health" style="color: var(--bs-success);">--</div>
+                            <small class="text-muted" id="learning-health-detail">Loading...</small>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Phase Progress Bar -->
+                <div class="card p-3 mb-3">
+                    <h6 class="mb-2"><i class="bi bi-bar-chart-steps"></i> Adaptive Ranking Progress</h6>
+                    <div class="d-flex align-items-center gap-2 mb-2">
+                        <div class="flex-grow-1">
+                            <div class="progress" style="height: 24px; border-radius: 12px;">
+                                <div class="progress-bar" id="learning-progress" role="progressbar" style="width: 0%; border-radius: 12px; transition: width 0.8s ease;" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100">
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="d-flex justify-content-between small text-muted">
+                        <span>Baseline (0)</span>
+                        <span>Rule-Based (20+)</span>
+                        <span>ML Model (200+)</span>
+                    </div>
+                </div>
+
+                <div class="row g-3">
+                    <!-- Tech Preferences (Layer 1) -->
+                    <div class="col-md-6">
+                        <div class="card p-3 h-100">
+                            <div class="d-flex justify-content-between align-items-center mb-3">
+                                <h6 class="mb-0"><i class="bi bi-cpu"></i> Tech Preferences</h6>
+                                <span class="badge bg-primary">Layer 1</span>
+                            </div>
+                            <div id="learning-tech-prefs">
+                                <div class="text-center text-muted py-3">
+                                    <i class="bi bi-hourglass-split" style="font-size: 1.5rem;"></i>
+                                    <p class="mt-2 mb-0 small">Patterns detected after using recall with feedback</p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Workflow Patterns (Layer 3) -->
+                    <div class="col-md-6">
+                        <div class="card p-3 h-100">
+                            <div class="d-flex justify-content-between align-items-center mb-3">
+                                <h6 class="mb-0"><i class="bi bi-diagram-3"></i> Workflow Patterns</h6>
+                                <span class="badge bg-info">Layer 3</span>
+                            </div>
+                            <div id="learning-workflows">
+                                <div class="text-center text-muted py-3">
+                                    <i class="bi bi-hourglass-split" style="font-size: 1.5rem;"></i>
+                                    <p class="mt-2 mb-0 small">Sequences detected after 30+ memories</p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="row g-3 mt-0">
+                    <!-- Source Quality -->
+                    <div class="col-md-6">
+                        <div class="card p-3 h-100">
+                            <div class="d-flex justify-content-between align-items-center mb-3">
+                                <h6 class="mb-0"><i class="bi bi-stars"></i> Source Quality</h6>
+                                <span class="badge bg-success">Per-Tool Scoring</span>
+                            </div>
+                            <div id="learning-sources">
+                                <div class="text-center text-muted py-3">
+                                    <i class="bi bi-hourglass-split" style="font-size: 1.5rem;"></i>
+                                    <p class="mt-2 mb-0 small">Quality scores computed after feedback signals</p>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Engagement & Privacy -->
+                    <div class="col-md-6">
+                        <div class="card p-3 h-100">
+                            <div class="d-flex justify-content-between align-items-center mb-3">
+                                <h6 class="mb-0"><i class="bi bi-shield-lock"></i> Privacy & Data</h6>
+                                <span class="badge bg-secondary">GDPR Compliant</span>
+                            </div>
+                            <div id="learning-privacy">
+                                <div class="small">
+                                    <div class="d-flex justify-content-between border-bottom py-1">
+                                        <span class="text-muted">Learning DB</span>
+                                        <span class="fw-bold" id="learning-db-size">--</span>
+                                    </div>
+                                    <div class="d-flex justify-content-between border-bottom py-1">
+                                        <span class="text-muted">Patterns learned</span>
+                                        <span class="fw-bold" id="learning-pattern-count">0</span>
+                                    </div>
+                                    <div class="d-flex justify-content-between border-bottom py-1">
+                                        <span class="text-muted">Models trained</span>
+                                        <span class="fw-bold" id="learning-model-count">0</span>
+                                    </div>
+                                    <div class="d-flex justify-content-between border-bottom py-1">
+                                        <span class="text-muted">Sources tracked</span>
+                                        <span class="fw-bold" id="learning-source-count">0</span>
+                                    </div>
+                                    <div class="d-flex justify-content-between py-1">
+                                        <span class="text-muted">Telemetry</span>
+                                        <span class="text-success fw-bold">None</span>
+                                    </div>
+                                </div>
+                                <div class="mt-2">
+                                    <button class="btn btn-sm btn-outline-danger" onclick="resetLearning()">
+                                        <i class="bi bi-trash"></i> Reset Learning Data
+                                    </button>
+                                    <small class="text-muted d-block mt-1">Deletes learning.db. Memories preserved.</small>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
             <!-- Live Events (v2.5) -->
             <div class="tab-pane fade" id="events-pane">
                 <div class="card p-3 mb-3">
@@ -1175,6 +1318,7 @@
     <script src="static/js/settings.js"></script>
     <script src="static/js/events.js"></script>
     <script src="static/js/agents.js"></script>
+    <script src="static/js/learning.js"></script>
     <script src="static/js/init.js"></script>
 
     <footer>

package/ui/js/init.js

@@ -29,3 +29,7 @@ if (eventsTab) eventsTab.addEventListener('shown.bs.tab', loadEventStats);
 
 var agentsTab = document.getElementById('agents-tab');
 if (agentsTab) agentsTab.addEventListener('shown.bs.tab', loadAgents);
+
+// v2.7 learning tab (graceful)
+var learningTab = document.getElementById('learning-tab');
+if (learningTab) learningTab.addEventListener('shown.bs.tab', loadLearning);