@geravant/sinain 1.12.0 → 1.14.0

package/sinain-memory/tests/conftest.py

@@ -1,189 +0,0 @@
-"""Shared fixtures for sinain-koog pytest test suite."""
-
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pytest
-
-# Ensure sinain-koog source is importable
-KOOG_DIR = Path(__file__).resolve().parent.parent
-if str(KOOG_DIR) not in sys.path:
-    sys.path.insert(0, str(KOOG_DIR))
-
-
-@pytest.fixture
-def tmp_memory_dir(tmp_path):
-    """Create a temporary memory directory with sample data."""
-    memory = tmp_path / "memory"
-    memory.mkdir()
-    (memory / "playbook-logs").mkdir()
-    (memory / "playbook-archive").mkdir()
-    (memory / "eval-logs").mkdir()
-    (memory / "eval-reports").mkdir()
-
-    # Sample playbook
-    playbook = (
-        "<!-- mining-index: 2026-02-21,2026-02-20 -->\n"
-        "# Sinain Playbook\n\n"
-        "## Established Patterns\n"
-        "- When OCR pipeline stalls, check camera frame queue depth (score: 0.8)\n"
-        "- When user explores new framework, spawn research agent proactively (score: 0.6)\n\n"
-        "## Observed\n"
-        "- User prefers concise Telegram messages over detailed ones\n"
-        "- Late evening sessions tend to be exploratory/research-heavy\n\n"
-        "## Stale\n"
-        "- Flutter overlay rendering glitch on macOS 15 [since: 2026-02-18]\n\n"
-        "<!-- effectiveness: outputs=8,positive=5,negative=1,neutral=2,rate=0.63,updated=2026-02-21 -->\n"
-    )
-    (memory / "sinain-playbook.md").write_text(playbook, encoding="utf-8")
-
-    # Sample daily memory files
-    for date in ["2026-02-21", "2026-02-20", "2026-02-19"]:
-        (memory / f"{date}.md").write_text(
-            f"# {date} Session Notes\n\n- Worked on OCR pipeline\n- Explored Flutter overlays\n",
-            encoding="utf-8",
-        )
-
-    # Sample playbook-log entries
-    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
-    entries = [
-        {
-            "ts": "2026-02-28T10:00:00Z",
-            "idle": False,
-            "sessionSummary": "Debugging OCR pipeline",
-            "signals": [{"description": "OCR pipeline backpressure detected", "priority": "high"}],
-            "recommendedAction": {"action": "sessions_spawn", "task": "Debug OCR backpressure", "confidence": 0.8},
-            "feedbackScores": {"avg": 0.35, "high": ["OCR fix"], "low": []},
-            "effectiveness": {"outputs": 8, "positive": 5, "negative": 1, "neutral": 2, "rate": 0.63},
-            "curateDirective": "normal",
-            "playbookChanges": {
-                "changes": {"added": ["new pattern"], "pruned": [], "promoted": []},
-                "staleItemActions": [],
-                "playbookLines": 12,
-            },
-            "output": {
-                "skip": False,
-                "suggestion": "Consider frame batching for OCR pipeline",
-                "insight": "Evening sessions correlate with exploratory work patterns",
-                "totalChars": 95,
-            },
-            "skipped": False,
-            "actionsConsidered": [
-                {"action": "sessions_spawn", "reason": "Debug OCR backpressure", "chosen": True}
-            ],
-        },
-        {
-            "ts": "2026-02-28T10:30:00Z",
-            "idle": True,
-            "sessionSummary": "User idle",
-            "signals": [],
-            "recommendedAction": None,
-            "feedbackScores": {"avg": 0, "high": [], "low": []},
-            "effectiveness": {"outputs": 8, "positive": 5, "negative": 1, "neutral": 2, "rate": 0.63},
-            "curateDirective": "normal",
-            "playbookChanges": {
-                "changes": {"added": [], "pruned": [], "promoted": []},
-                "staleItemActions": [],
-                "playbookLines": 12,
-            },
-            "output": {
-                "skip": True,
-                "skipReason": "User is idle and no new patterns detected in playbook since last analysis",
-            },
-            "skipped": True,
-            "miningResult": {
-                "findings": "Found cross-day OCR pattern",
-                "newPatterns": ["frame dropping improves OCR accuracy"],
-                "contradictions": [],
-                "preferences": ["user prefers minimal configs"],
-                "minedSources": ["2026-02-21.md"],
-            },
-            "actionsConsidered": [],
-        },
-    ]
-
-    log_file = memory / "playbook-logs" / f"{today}.jsonl"
-    log_file.write_text(
-        "\n".join(json.dumps(e) for e in entries) + "\n",
-        encoding="utf-8",
-    )
-
-    return memory
-
-
-@pytest.fixture
-def tmp_modules_dir(tmp_path):
-    """Create a temporary modules directory with sample module."""
-    modules = tmp_path / "modules"
-    modules.mkdir()
-
-    # Registry
-    registry = {
-        "version": 1,
-        "modules": {
-            "react-native-dev": {
-                "status": "active",
-                "priority": 85,
-                "activatedAt": "2026-02-20T10:00:00Z",
-                "lastTriggered": None,
-                "locked": False,
-            },
-            "ocr-pipeline": {
-                "status": "suspended",
-                "priority": 70,
-                "activatedAt": None,
-                "lastTriggered": None,
-                "locked": False,
-            },
-        },
-    }
-    (modules / "module-registry.json").write_text(
-        json.dumps(registry, indent=2), encoding="utf-8"
-    )
-
-    # Module directories
-    rn_dir = modules / "react-native-dev"
-    rn_dir.mkdir()
-    (rn_dir / "manifest.json").write_text(json.dumps({
-        "id": "react-native-dev",
-        "name": "React Native Development",
-        "description": "Patterns for RN development",
-        "version": "1.0.0",
-        "priority": {"default": 85, "range": [50, 100]},
-        "triggers": {},
-        "locked": False,
-    }, indent=2), encoding="utf-8")
-    (rn_dir / "patterns.md").write_text(
-        "# React Native Development\n\n## Established Patterns\n- Use Hermes engine\n",
-        encoding="utf-8",
-    )
-
-    return modules
-
-
-@pytest.fixture
-def sample_log_entry():
-    """A sample playbook-log entry for testing."""
-    return {
-        "ts": "2026-02-28T10:00:00Z",
-        "idle": False,
-        "signals": [{"description": "OCR pipeline backpressure detected", "priority": "high"}],
-        "recommendedAction": {"action": "sessions_spawn", "task": "Debug OCR backpressure", "confidence": 0.8},
-        "feedbackScores": {"avg": 0.35, "high": ["OCR fix"], "low": []},
-        "effectiveness": {"outputs": 8, "positive": 5, "negative": 1, "neutral": 2, "rate": 0.63},
-        "curateDirective": "normal",
-        "interpretation": "",
-        "playbookChanges": {
-            "changes": {"added": ["new pattern"], "pruned": [], "promoted": []},
-            "staleItemActions": [],
-            "playbookLines": 12,
-        },
-        "output": {
-            "skip": False,
-            "suggestion": "Consider frame batching for OCR pipeline",
-            "insight": "Evening sessions correlate with exploratory work patterns",
-            "totalChars": 95,
-        },
-    }

package/sinain-memory/tests/test_curator_helpers.py

@@ -1,94 +0,0 @@
-"""Tests for playbook_curator.py: extract_header_footer() and reassemble_playbook()."""
-
-from playbook_curator import extract_header_footer, reassemble_playbook
-
-
-class TestExtractHeaderFooter:
-    def test_standard_playbook(self):
-        playbook = (
-            "<!-- mining-index: 2026-02-21 -->\n"
-            "# Playbook\n"
-            "- Pattern 1\n"
-            "- Pattern 2\n"
-            "<!-- effectiveness: rate=0.63 -->\n"
-        )
-        header, body, footer = extract_header_footer(playbook)
-        assert "mining-index" in header
-        assert "# Playbook" in body
-        assert "- Pattern 1" in body
-        assert "effectiveness" in footer
-
-    def test_no_header(self):
-        playbook = "# Playbook\n- Pattern 1\n<!-- effectiveness: rate=0.5 -->\n"
-        header, body, footer = extract_header_footer(playbook)
-        assert header == ""
-        assert "# Playbook" in body
-        assert "effectiveness" in footer
-
-    def test_no_footer(self):
-        playbook = "<!-- mining-index: 2026-02-21 -->\n# Playbook\n- Pattern 1\n"
-        header, body, footer = extract_header_footer(playbook)
-        assert "mining-index" in header
-        assert "# Playbook" in body
-        assert footer == ""
-
-    def test_empty_playbook(self):
-        header, body, footer = extract_header_footer("")
-        assert header == ""
-        assert body == ""
-        assert footer == ""
-
-    def test_body_lines_exclude_comments(self):
-        playbook = (
-            "<!-- mining-index: 2026-02-21 -->\n"
-            "line1\nline2\nline3\n"
-            "<!-- effectiveness: rate=0.5 -->\n"
-        )
-        header, body, footer = extract_header_footer(playbook)
-        body_lines = [l for l in body.strip().splitlines() if l.strip()]
-        assert len(body_lines) == 3
-
-
-class TestReassemblePlaybook:
-    def test_standard_reassembly(self):
-        result = reassemble_playbook(
-            "<!-- mining-index: 2026-02-21 -->",
-            "# Playbook\n- Pattern 1",
-            "<!-- effectiveness: rate=0.5 -->",
-        )
-        assert "mining-index" in result
-        assert "# Playbook" in result
-        assert "effectiveness" in result
-        assert result.endswith("\n")
-
-    def test_body_limit_enforced(self):
-        body_lines = [f"- Pattern {i}" for i in range(60)]
-        body = "\n".join(body_lines)
-        result = reassemble_playbook("", body, "")
-        # Count non-empty lines in body section
-        result_body_lines = [l for l in result.strip().splitlines() if l.strip()]
-        assert len(result_body_lines) <= 50
-
-    def test_empty_parts_handled(self):
-        result = reassemble_playbook("", "body content", "")
-        assert "body content" in result
-        assert result.endswith("\n")
-
-    def test_all_parts_empty(self):
-        result = reassemble_playbook("", "", "")
-        assert result == "\n"
-
-    def test_50_lines_exactly(self):
-        body_lines = [f"- Pattern {i}" for i in range(50)]
-        body = "\n".join(body_lines)
-        result = reassemble_playbook("<!-- header -->", body, "<!-- footer -->")
-        # Should not truncate — 50 is exactly the limit
-        assert "Pattern 49" in result
-
-    def test_51_lines_truncated(self):
-        body_lines = [f"- Pattern {i}" for i in range(51)]
-        body = "\n".join(body_lines)
-        result = reassemble_playbook("<!-- header -->", body, "<!-- footer -->")
-        # Line 51 (Pattern 50) should be cut
-        assert "Pattern 50" not in result
-        assert "Pattern 49" in result

package/sinain-memory/tests/test_embedder.py

@@ -1,210 +0,0 @@
-"""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

@@ -1,124 +0,0 @@
-"""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  ")