@geravant/sinain 1.0.1

package/sinain-memory/tests/test_embedder.py

@@ -0,0 +1,210 @@
+"""Tests for embedder.py — dual-strategy embeddings + vector search."""
+
+import math
+import struct
+import pytest
+from unittest.mock import patch, MagicMock
+
+from triplestore import TripleStore
+from embedder import Embedder, _vec_to_blob, _blob_to_vec, _text_hash, _dot, _norm
+
+
+@pytest.fixture
+def db_path(tmp_path):
+    return str(tmp_path / "test.db")
+
+
+@pytest.fixture
+def store(db_path):
+    s = TripleStore(db_path)
+    yield s
+    s.close()
+
+
+@pytest.fixture
+def embedder(db_path, store):
+    """Embedder with a pre-initialized store."""
+    e = Embedder(db_path)
+    yield e
+    e.close()
+
+
+# ----- Utility functions -----
+
+class TestVecConversion:
+    def test_roundtrip(self):
+        vec = [0.1, 0.2, 0.3, -0.5, 1.0]
+        blob = _vec_to_blob(vec)
+        recovered = _blob_to_vec(blob)
+        for a, b in zip(vec, recovered):
+            assert abs(a - b) < 1e-6
+
+    def test_empty_vec(self):
+        assert _vec_to_blob([]) == b""
+        assert _blob_to_vec(b"") == []
+
+
+class TestTextHash:
+    def test_deterministic(self):
+        assert _text_hash("hello") == _text_hash("hello")
+
+    def test_different_texts(self):
+        assert _text_hash("hello") != _text_hash("world")
+
+    def test_length(self):
+        assert len(_text_hash("test")) == 16
+
+
+class TestDotAndNorm:
+    def test_dot_product(self):
+        assert _dot([1, 2, 3], [4, 5, 6]) == 32
+
+    def test_norm(self):
+        assert abs(_norm([3, 4]) - 5.0) < 1e-6
+
+    def test_unit_vector_norm(self):
+        assert abs(_norm([1, 0, 0]) - 1.0) < 1e-6
+
+
+# ----- Embedder with mocked API -----
+
+def _mock_openrouter_response(texts):
+    """Create a mock OpenRouter embedding response."""
+    # Generate deterministic fake embeddings (10-dim for testing)
+    embeddings = []
+    for i, text in enumerate(texts):
+        vec = [(hash(text + str(j)) % 1000) / 1000.0 for j in range(10)]
+        embeddings.append({"index": i, "embedding": vec})
+    return MagicMock(
+        status_code=200,
+        json=lambda: {"data": embeddings},
+        raise_for_status=lambda: None,
+    )
+
+
+class TestEmbedOpenRouter:
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    @patch("requests.post")
+    def test_embed_calls_api(self, mock_post, embedder):
+        mock_post.return_value = _mock_openrouter_response(["hello"])
+        result = embedder.embed(["hello"])
+        assert len(result) == 1
+        assert len(result[0]) == 10
+        mock_post.assert_called_once()
+
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    @patch("requests.post")
+    def test_embed_multiple(self, mock_post, embedder):
+        texts = ["hello", "world", "test"]
+        mock_post.return_value = _mock_openrouter_response(texts)
+        result = embedder.embed(texts)
+        assert len(result) == 3
+
+    def test_embed_empty(self, embedder):
+        assert embedder.embed([]) == []
+
+
+class TestEmbedFallback:
+    @patch.dict("os.environ", {}, clear=True)
+    def test_no_api_key_tries_local(self, embedder):
+        """Without API key, should try local model (which may not be installed)."""
+        result = embedder.embed(["test"])
+        # Either local model works or returns empty vectors
+        assert isinstance(result, list)
+
+
+# ----- Store embeddings -----
+
+class TestStoreEmbeddings:
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    @patch("requests.post")
+    def test_store_and_dedup(self, mock_post, embedder):
+        mock_post.return_value = _mock_openrouter_response(["pattern text"])
+        count1 = embedder.store_embeddings({"pattern:test": "pattern text"})
+        assert count1 == 1
+
+        # Same text → should skip
+        count2 = embedder.store_embeddings({"pattern:test": "pattern text"})
+        assert count2 == 0
+
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    @patch("requests.post")
+    def test_store_update_on_text_change(self, mock_post, embedder):
+        mock_post.return_value = _mock_openrouter_response(["v1"])
+        embedder.store_embeddings({"pattern:test": "v1"})
+
+        mock_post.return_value = _mock_openrouter_response(["v2"])
+        count = embedder.store_embeddings({"pattern:test": "v2"})
+        assert count == 1  # re-embedded because text changed
+
+    def test_store_empty(self, embedder):
+        assert embedder.store_embeddings({}) == 0
+
+
+# ----- Vector search -----
+
+class TestVectorSearch:
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    @patch("requests.post")
+    def test_search_returns_sorted(self, mock_post, embedder):
+        # Store some embeddings with known vectors
+        # We'll bypass embed() and insert directly
+        from embedder import _vec_to_blob, _now_iso
+        vecs = {
+            "pattern:a": [1.0, 0.0, 0.0],
+            "pattern:b": [0.0, 1.0, 0.0],
+            "pattern:c": [0.7, 0.7, 0.0],  # closest to query [1,0,0] after normalization
+        }
+        for eid, vec in vecs.items():
+            embedder._conn.execute(
+                "INSERT INTO embeddings (entity_id, vector, text_hash, model, dimensions, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (eid, _vec_to_blob(vec), "hash", "test", len(vec), _now_iso()),
+            )
+        embedder._conn.commit()
+
+        results = embedder.vector_search([1.0, 0.0, 0.0], top_k=3)
+        assert len(results) == 3
+        # pattern:a should be first (exact match, cosine=1.0)
+        assert results[0][0] == "pattern:a"
+        assert abs(results[0][1] - 1.0) < 1e-6
+
+    def test_search_empty_db(self, embedder):
+        results = embedder.vector_search([1.0, 0.0], top_k=5)
+        assert results == []
+
+    def test_search_empty_query(self, embedder):
+        assert embedder.vector_search([], top_k=5) == []
+
+    @patch.dict("os.environ", {"OPENROUTER_API_KEY": "test-key"})
+    def test_search_with_type_filter(self, embedder):
+        from embedder import _vec_to_blob, _now_iso
+        for eid, vec in [
+            ("pattern:x", [1.0, 0.0]),
+            ("concept:y", [0.9, 0.1]),
+        ]:
+            embedder._conn.execute(
+                "INSERT INTO embeddings (entity_id, vector, text_hash, model, dimensions, created_at) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (eid, _vec_to_blob(vec), "hash", "test", 2, _now_iso()),
+            )
+        embedder._conn.commit()
+
+        results = embedder.vector_search([1.0, 0.0], top_k=5, entity_types=["pattern"])
+        assert len(results) == 1
+        assert results[0][0] == "pattern:x"
+
+
+# ----- Schema -----
+
+class TestEmbeddingsSchema:
+    def test_embeddings_table_exists(self, embedder):
+        rows = embedder._conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='embeddings'"
+        ).fetchall()
+        assert len(rows) == 1
+
+    def test_embeddings_columns(self, embedder):
+        info = embedder._conn.execute("PRAGMA table_info(embeddings)").fetchall()
+        col_names = {row["name"] for row in info}
+        assert col_names == {"entity_id", "vector", "text_hash", "model", "dimensions", "created_at"}

package/sinain-memory/tests/test_extract_json.py

@@ -0,0 +1,124 @@
+"""Tests for common.extract_json() — all three extraction stages + truncation repair."""
+
+import pytest
+from common import extract_json
+
+
+class TestStage1DirectParse:
+    def test_clean_object(self):
+        result = extract_json('{"signals": [], "idle": true}')
+        assert result["signals"] == []
+        assert result["idle"] is True
+
+    def test_clean_array(self):
+        result = extract_json('[{"a": 1}, {"b": 2}]')
+        assert len(result) == 2
+
+    def test_whitespace_padded(self):
+        result = extract_json('  \n  {"key": "value"}  \n  ')
+        assert result["key"] == "value"
+
+    def test_unicode(self):
+        result = extract_json('{"msg": "привет мир"}')
+        assert result["msg"] == "привет мир"
+
+
+class TestStage2MarkdownFences:
+    def test_fenced_json(self):
+        result = extract_json('```json\n{"signals": ["x"], "idle": false}\n```')
+        assert result["signals"] == ["x"]
+
+    def test_fenced_no_lang_tag(self):
+        result = extract_json('```\n{"findings": "test"}\n```')
+        assert result["findings"] == "test"
+
+    def test_text_before_fence(self):
+        result = extract_json('Here is the result:\n```json\n{"skip": true}\n```')
+        assert result["skip"] is True
+
+    def test_text_after_fence(self):
+        result = extract_json('```json\n{"skip": false}\n```\nHope this helps!')
+        assert result["skip"] is False
+
+    def test_text_before_and_after_fence(self):
+        result = extract_json(
+            'I analyzed it.\n```json\n{"curateDirective": "normal"}\n```\nLet me know.'
+        )
+        assert result["curateDirective"] == "normal"
+
+
+class TestStage3BalancedBrace:
+    def test_prose_then_json(self):
+        result = extract_json('The analysis result is: {"signals": ["a"], "idle": true}')
+        assert result["signals"] == ["a"]
+
+    def test_json_then_prose(self):
+        result = extract_json('{"findings": "test"} That is all.')
+        assert result["findings"] == "test"
+
+    def test_nested_braces(self):
+        result = extract_json('{"outer": {"inner": {"deep": 1}}, "key": "val"}')
+        assert result["outer"]["inner"]["deep"] == 1
+
+    def test_strings_with_braces(self):
+        result = extract_json('{"msg": "use {braces} like this", "ok": true}')
+        assert result["msg"] == "use {braces} like this"
+
+    def test_prose_embedded_array(self):
+        # Balanced-brace scanner tries {} before [], so it finds the first object
+        result = extract_json('Result: [{"a": 1}, {"b": 2}]')
+        assert isinstance(result, (dict, list))
+
+    def test_escaped_quotes_in_strings(self):
+        result = extract_json(r'{"msg": "he said \"hello\"", "ok": true}')
+        assert result["ok"] is True
+
+
+class TestStage4TruncationRepair:
+    def test_missing_closing_brace(self):
+        result = extract_json('{"signals": ["a", "b"], "idle": true, "extra": "val')
+        assert result["signals"] == ["a", "b"]
+
+    def test_missing_two_closing_braces(self):
+        result = extract_json('{"outer": {"inner": "val"')
+        assert result["outer"]["inner"] == "val"
+
+    def test_truncated_array_in_object(self):
+        result = extract_json('{"items": [1, 2, 3')
+        assert result["items"] == [1, 2, 3]
+
+    def test_trailing_comma(self):
+        result = extract_json('{"a": 1, "b": 2,')
+        assert result["a"] == 1
+
+    def test_mid_key_truncation(self):
+        result = extract_json('{"valid": 1, "partial_ke')
+        assert result["valid"] == 1
+
+    def test_prose_plus_truncated(self):
+        result = extract_json(
+            'Here is the result: {"findings": "some text", "patterns": ["p1"'
+        )
+        assert result["findings"] == "some text"
+
+    def test_truncated_simple_object(self):
+        result = extract_json('{"unclosed": "brace"')
+        assert result["unclosed"] == "brace"
+
+
+class TestFailureCases:
+    def test_no_json_at_all(self):
+        with pytest.raises(ValueError):
+            extract_json("This is just plain text with no JSON.")
+
+    def test_empty_string(self):
+        with pytest.raises(ValueError):
+            extract_json("")
+
+    def test_no_brackets(self):
+        with pytest.raises(ValueError):
+            extract_json("just some random text without any brackets")
+
+    def test_only_whitespace(self):
+        with pytest.raises(ValueError):
+            extract_json("   \n\n  ")

package/sinain-memory/tests/test_feedback_computation.py

@@ -0,0 +1,121 @@
+"""Tests for feedback_analyzer.py: compute_effectiveness() and determine_directive()."""
+
+from feedback_analyzer import compute_effectiveness, determine_directive, extract_feedback_scores
+
+
+class TestComputeEffectiveness:
+    def test_no_logs(self):
+        result = compute_effectiveness([])
+        assert result == {"outputs": 0, "positive": 0, "negative": 0, "neutral": 0, "rate": 0.0}
+
+    def test_all_skipped(self):
+        logs = [{"ts": "2026-02-28T10:00:00Z", "skipped": True}] * 5
+        result = compute_effectiveness(logs)
+        assert result["outputs"] == 0
+
+    def test_positive_outcomes(self):
+        logs = [
+            {"ts": "2026-02-28T10:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T10:30:00Z", "skipped": True, "feedbackScores": {"avg": 0.5}},
+            {"ts": "2026-02-28T11:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T11:30:00Z", "skipped": True, "feedbackScores": {"avg": 0.6}},
+        ]
+        result = compute_effectiveness(logs)
+        assert result["outputs"] == 2
+        assert result["positive"] == 2
+        assert result["rate"] == 1.0
+
+    def test_negative_outcomes(self):
+        logs = [
+            {"ts": "2026-02-28T10:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T10:30:00Z", "skipped": True, "feedbackScores": {"avg": -0.5}},
+        ]
+        result = compute_effectiveness(logs)
+        assert result["negative"] == 1
+
+    def test_neutral_for_last_tick(self):
+        """Last tick with output has no next tick for feedback — counted as neutral."""
+        logs = [{"ts": "2026-02-28T10:00:00Z", "skipped": False}]
+        result = compute_effectiveness(logs)
+        assert result["neutral"] == 1
+
+    def test_mixed_outcomes(self):
+        logs = [
+            {"ts": "2026-02-28T10:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T10:30:00Z", "feedbackScores": {"avg": 0.5}},  # positive
+            {"ts": "2026-02-28T11:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T11:30:00Z", "feedbackScores": {"avg": -0.3}},  # negative
+            {"ts": "2026-02-28T12:00:00Z", "skipped": False},
+            {"ts": "2026-02-28T12:30:00Z", "feedbackScores": {"avg": 0.05}},  # neutral
+        ]
+        result = compute_effectiveness(logs)
+        assert result["outputs"] == 3
+        assert result["positive"] == 1
+        assert result["negative"] == 1
+        assert result["neutral"] == 1
+        assert result["rate"] == round(1 / 3, 2)
+
+    def test_rate_is_rounded(self):
+        logs = [
+            {"ts": f"2026-02-28T1{i}:00:00Z", "skipped": False}
+            for i in range(3)
+        ] + [
+            {"ts": f"2026-02-28T1{i}:30:00Z", "feedbackScores": {"avg": 0.5}}
+            for i in range(3)
+        ]
+        result = compute_effectiveness(logs)
+        assert isinstance(result["rate"], float)
+
+
+class TestDetermineDirective:
+    def test_insufficient_data(self):
+        assert determine_directive({"outputs": 3, "rate": 0.8}) == "insufficient_data"
+        assert determine_directive({"outputs": 0, "rate": 0.0}) == "insufficient_data"
+        assert determine_directive({"outputs": 4, "rate": 0.5}) == "insufficient_data"
+
+    def test_aggressive_prune(self):
+        assert determine_directive({"outputs": 10, "rate": 0.2}) == "aggressive_prune"
+        assert determine_directive({"outputs": 5, "rate": 0.39}) == "aggressive_prune"
+
+    def test_stability(self):
+        assert determine_directive({"outputs": 10, "rate": 0.8}) == "stability"
+        assert determine_directive({"outputs": 5, "rate": 0.71}) == "stability"
+
+    def test_normal(self):
+        assert determine_directive({"outputs": 10, "rate": 0.5}) == "normal"
+        assert determine_directive({"outputs": 5, "rate": 0.4}) == "normal"
+        assert determine_directive({"outputs": 5, "rate": 0.7}) == "normal"
+
+    def test_boundary_values(self):
+        # Exactly 5 outputs is enough data
+        assert determine_directive({"outputs": 5, "rate": 0.5}) != "insufficient_data"
+        # rate=0.4 is normal (not aggressive_prune)
+        assert determine_directive({"outputs": 5, "rate": 0.4}) == "normal"
+        # rate=0.7 is normal (not stability)
+        assert determine_directive({"outputs": 5, "rate": 0.7}) == "normal"
+
+
+class TestExtractFeedbackScores:
+    def test_empty_logs(self):
+        result = extract_feedback_scores([])
+        assert result["avg"] == 0
+        assert result["high"] == []
+        assert result["low"] == []
+
+    def test_with_scores(self):
+        logs = [
+            {"feedbackScores": {"avg": 0.5, "high": ["good A"], "low": ["bad A"]}},
+            {"feedbackScores": {"avg": 0.3, "high": ["good B"], "low": []}},
+        ]
+        result = extract_feedback_scores(logs)
+        assert result["avg"] == 0.4
+        assert "good A" in result["high"]
+        assert "good B" in result["high"]
+
+    def test_limits_to_5_patterns(self):
+        logs = [
+            {"feedbackScores": {"avg": 0.1, "high": [f"pattern {i}"], "low": []}}
+            for i in range(10)
+        ]
+        result = extract_feedback_scores(logs)
+        assert len(result["high"]) <= 5

package/sinain-memory/tests/test_miner_helpers.py

@@ -0,0 +1,71 @@
+"""Tests for memory_miner.py: get_unmined_files() and update_mining_index()."""
+
+from pathlib import Path
+from memory_miner import get_unmined_files, update_mining_index
+from common import parse_mining_index
+
+
+class TestGetUnminedFiles:
+    def test_all_mined(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        mined = ["2026-02-21", "2026-02-20", "2026-02-19"]
+        result = get_unmined_files(memory_dir, mined)
+        assert result == []
+
+    def test_some_unmined(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        mined = ["2026-02-21"]
+        result = get_unmined_files(memory_dir, mined)
+        basenames = [Path(f).stem for f in result]
+        assert "2026-02-20" in basenames
+        assert "2026-02-19" in basenames
+        assert "2026-02-21" not in basenames
+
+    def test_none_mined(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        result = get_unmined_files(memory_dir, [])
+        assert len(result) == 3  # all 3 daily files
+
+    def test_no_daily_files(self, tmp_path):
+        empty_memory = tmp_path / "empty-memory"
+        empty_memory.mkdir()
+        result = get_unmined_files(str(empty_memory), [])
+        assert result == []
+
+
+class TestUpdateMiningIndex:
+    def test_adds_new_dates(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        playbook = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        update_mining_index(memory_dir, playbook, ["2026-02-22"])
+
+        updated = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        index = parse_mining_index(updated)
+        assert "2026-02-22" in index
+
+    def test_deduplicates(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        playbook = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        # 2026-02-21 is already in index
+        update_mining_index(memory_dir, playbook, ["2026-02-21"])
+
+        updated = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        index = parse_mining_index(updated)
+        assert index.count("2026-02-21") == 1
+
+    def test_creates_playbook_if_missing(self, tmp_path):
+        memory_dir = str(tmp_path)
+        update_mining_index(memory_dir, "", ["2026-02-25"])
+
+        playbook = (tmp_path / "sinain-playbook.md").read_text()
+        assert "mining-index:" in playbook
+        assert "2026-02-25" in playbook
+
+    def test_sorted_descending(self, tmp_memory_dir):
+        memory_dir = str(tmp_memory_dir)
+        playbook = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        update_mining_index(memory_dir, playbook, ["2026-02-22", "2026-02-23"])
+
+        updated = (tmp_memory_dir / "sinain-playbook.md").read_text()
+        index = parse_mining_index(updated)
+        assert index == sorted(index, reverse=True)