@geravant/sinain 1.0.1

package/sinain-memory/tests/test_triple_ingest.py

@@ -0,0 +1,191 @@
+"""Tests for triple_ingest.py — CLI entry point."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from triplestore import TripleStore
+
+
+KOOG_DIR = Path(__file__).resolve().parent.parent
+
+
+@pytest.fixture
+def memory_dir(tmp_path):
+    """Create a temporary memory directory with playbook."""
+    mem = tmp_path / "memory"
+    mem.mkdir()
+    (mem / "sinain-playbook.md").write_text(
+        "## Established Patterns\n"
+        "- OCR pipeline stalls when queue depth > 10 (score: 0.8)\n"
+        "- Use frame batching for throughput (score: 0.6)\n"
+        "- Spawn research agent proactively\n",
+        encoding="utf-8",
+    )
+    return str(mem)
+
+
+@pytest.fixture
+def modules_dir(tmp_path):
+    """Create a temporary modules directory with a test module."""
+    modules = tmp_path / "modules"
+    modules.mkdir()
+    mod_dir = modules / "test-mod"
+    mod_dir.mkdir()
+    (mod_dir / "manifest.json").write_text(json.dumps({
+        "name": "Test Module",
+        "description": "Testing patterns",
+        "version": "1.0.0",
+    }))
+    (mod_dir / "patterns.md").write_text("## Patterns\n- Test pattern one\n- Test pattern two\n")
+    return str(modules)
+
+
+class TestSignalIngest:
+    def test_signal_ingest_creates_db(self, memory_dir):
+        signal = json.dumps({
+            "signals": [{"description": "OCR stall", "priority": "high"}],
+            "output": {"suggestion": "Try batching"},
+        })
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--signal-result", signal,
+             "--tick-ts", "2026-03-01T10:00:00Z"],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["ingested"] > 0
+        assert data["source"] == "signal"
+        assert "txId" in data
+        # DB should exist
+        assert Path(memory_dir, "triplestore.db").exists()
+
+    def test_signal_ingest_requires_tick_ts(self, memory_dir):
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--signal-result", '{"signals":[]}'],
+            capture_output=True, text=True, timeout=10,
+        )
+        assert result.returncode != 0
+
+
+class TestPlaybookIngest:
+    def test_playbook_ingest(self, memory_dir):
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-playbook"],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["ingested"] > 0
+        assert data["source"] == "playbook"
+
+
+class TestSessionIngest:
+    def test_session_ingest(self, memory_dir):
+        session = json.dumps({
+            "ts": "2026-03-01T09:00:00Z",
+            "summary": "Debugging OCR pipeline issues",
+            "toolsUsed": ["Read", "Edit"],
+        })
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-session", session],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["ingested"] > 0
+        assert data["source"] == "session"
+
+
+class TestMiningIngest:
+    def test_mining_ingest(self, memory_dir):
+        mining = json.dumps({
+            "newPatterns": ["Frame dropping improves OCR"],
+            "preferences": ["User prefers minimal output"],
+            "contradictions": [],
+        })
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-mining", mining],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["ingested"] > 0
+        assert data["source"] == "mining"
+
+
+class TestModuleIngest:
+    def test_module_ingest(self, memory_dir, modules_dir):
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-module", "test-mod",
+             "--modules-dir", modules_dir],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["ingested"] > 0
+        assert data["source"] == "module"
+        assert data["module"] == "test-mod"
+
+    def test_module_requires_modules_dir(self, memory_dir):
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-module", "test-mod"],
+            capture_output=True, text=True, timeout=10,
+        )
+        assert result.returncode != 0
+
+
+class TestRetractModule:
+    def test_retract_module(self, memory_dir, modules_dir):
+        # First ingest
+        subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--ingest-module", "test-mod",
+             "--modules-dir", modules_dir],
+            capture_output=True, text=True, timeout=30,
+        )
+        # Then retract
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--retract-module", "test-mod"],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        data = json.loads(result.stdout.strip())
+        assert data["source"] == "module"
+        assert data["module"] == "test-mod"
+
+
+class TestOutputFormat:
+    def test_output_is_valid_json(self, memory_dir):
+        signal = json.dumps({"signals": []})
+        result = subprocess.run(
+            [sys.executable, str(KOOG_DIR / "triple_ingest.py"),
+             "--memory-dir", memory_dir,
+             "--signal-result", signal,
+             "--tick-ts", "2026-03-01"],
+            capture_output=True, text=True, timeout=30,
+        )
+        assert result.returncode == 0
+        data = json.loads(result.stdout.strip())
+        assert isinstance(data, dict)
+        assert "ingested" in data
+        assert "source" in data

package/sinain-memory/tests/test_triple_migrate.py

@@ -0,0 +1,138 @@
+"""Tests for triple_migrate.py — historical data migration to triple store."""
+
+import json
+import sys
+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))
+
+from triple_extractor import TripleExtractor
+from triple_migrate import (
+    MIGRATION_ENTITY,
+    migrate_daily_memories,
+    migrate_modules,
+    migrate_playbook,
+    migrate_playbook_logs,
+)
+from triplestore import TripleStore
+
+
+@pytest.fixture
+def store(tmp_path):
+    db = tmp_path / "triplestore.db"
+    return TripleStore(str(db))
+
+
+@pytest.fixture
+def extractor(store):
+    return TripleExtractor(store)
+
+
+class TestMigratePlaybook:
+    def test_extracts_patterns(self, extractor, store, tmp_memory_dir):
+        count = migrate_playbook(extractor, store, str(tmp_memory_dir))
+        assert count > 0
+        # Should find at least the OCR and research-agent patterns
+        patterns = store.entities_with_attr("text")
+        pattern_ids = [eid for eid, _ in patterns if eid.startswith("pattern:")]
+        assert len(pattern_ids) >= 2
+
+    def test_empty_playbook_returns_zero(self, extractor, store, tmp_path):
+        memory = tmp_path / "empty_memory"
+        memory.mkdir()
+        count = migrate_playbook(extractor, store, str(memory))
+        assert count == 0
+
+
+class TestMigrateModules:
+    def test_active_only(self, extractor, store, tmp_modules_dir):
+        mod_count, triple_count = migrate_modules(extractor, store, str(tmp_modules_dir))
+        # Only react-native-dev is active; ocr-pipeline is suspended
+        assert mod_count == 1
+        assert triple_count > 0
+        # Module entity should exist
+        ent = store.entity("module:react-native-dev")
+        assert "name" in ent
+        assert ent["name"] == ["React Native Development"]
+
+    def test_no_registry(self, extractor, store, tmp_path):
+        mod_count, triple_count = migrate_modules(extractor, store, str(tmp_path / "nope"))
+        assert mod_count == 0
+        assert triple_count == 0
+
+
+class TestMigratePlaybookLogs:
+    def test_skips_idle_no_signals(self, extractor, store, tmp_memory_dir):
+        """Idle entries with empty signals should be skipped."""
+        file_count, triple_count = migrate_playbook_logs(
+            extractor, store, str(tmp_memory_dir)
+        )
+        assert file_count >= 1
+        assert triple_count > 0
+        # The second entry in conftest is idle=True + signals=[], should be skipped
+        # First entry has ts=2026-02-28T10:00:00Z — should be ingested
+        ent = store.entity("signal:2026-02-28T10:00:00Z")
+        assert ent  # non-idle entry should exist
+        # Idle entry should NOT exist
+        idle_ent = store.entity("signal:2026-02-28T10:30:00Z")
+        assert not idle_ent
+
+    def test_no_log_dir(self, extractor, store, tmp_path):
+        memory = tmp_path / "empty"
+        memory.mkdir()
+        file_count, triple_count = migrate_playbook_logs(extractor, store, str(memory))
+        assert file_count == 0
+
+
+class TestMigrateDailyMemories:
+    def test_creates_observation_entities(self, extractor, store, tmp_memory_dir):
+        file_count, triple_count = migrate_daily_memories(
+            extractor, store, str(tmp_memory_dir)
+        )
+        # conftest creates 3 daily memory files
+        assert file_count == 3
+        assert triple_count > 0
+        # Check one observation entity
+        ent = store.entity("observation:2026-02-21")
+        assert "text" in ent
+        assert "source" in ent
+        assert ent["source"] == ["daily_memory"]
+
+    def test_truncates_long_text(self, extractor, store, tmp_path):
+        memory = tmp_path / "memory"
+        memory.mkdir()
+        (memory / "2026-01-01.md").write_text("x" * 5000, encoding="utf-8")
+        migrate_daily_memories(extractor, store, str(memory))
+        ent = store.entity("observation:2026-01-01")
+        assert len(ent["text"][0]) == 2000
+
+
+class TestIdempotency:
+    def test_stamp_prevents_remigration(self, store, tmp_path):
+        """Once migration:v1 exists, the script should be a no-op."""
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, MIGRATION_ENTITY, "completed_at", "2026-03-05T00:00:00Z")
+        existing = store.entity(MIGRATION_ENTITY)
+        assert existing  # guard entity exists
+
+    def test_full_migration_stamps(self, extractor, store, tmp_memory_dir, tmp_modules_dir):
+        """Full migration should create the stamp entity."""
+        migrate_playbook(extractor, store, str(tmp_memory_dir))
+        migrate_modules(extractor, store, str(tmp_modules_dir))
+        migrate_playbook_logs(extractor, store, str(tmp_memory_dir))
+        migrate_daily_memories(extractor, store, str(tmp_memory_dir))
+
+        # Simulate stamping
+        stats = store.stats()
+        stamp_tx = store.begin_tx("migration:stamp")
+        store.assert_triple(stamp_tx, MIGRATION_ENTITY, "completed_at", "2026-03-05T00:00:00Z")
+        store.assert_triple(stamp_tx, MIGRATION_ENTITY, "total_triples", str(stats["triples"]))
+
+        ent = store.entity(MIGRATION_ENTITY)
+        assert "completed_at" in ent
+        assert int(ent["total_triples"][0]) > 0

package/sinain-memory/tests/test_triplestore.py

@@ -0,0 +1,248 @@
+"""Tests for triplestore.py — EAV triple store."""
+
+import os
+import pytest
+from triplestore import TripleStore
+
+
+@pytest.fixture
+def store(tmp_path):
+    """Create a fresh triple store in a temp directory."""
+    db_path = tmp_path / "test.db"
+    s = TripleStore(str(db_path))
+    yield s
+    s.close()
+
+
+@pytest.fixture
+def populated_store(store):
+    """Store with sample data across two transactions."""
+    tx1 = store.begin_tx("test", session_key="sess-1")
+    store.assert_triple(tx1, "signal:2026-03-01T10:00", "description", "OCR stall")
+    store.assert_triple(tx1, "signal:2026-03-01T10:00", "priority", "high")
+    store.assert_triple(tx1, "signal:2026-03-01T10:00", "related_to", "concept:ocr", "ref")
+    store.assert_triple(tx1, "concept:ocr", "name", "OCR")
+    store.assert_triple(tx1, "pattern:frame-batch", "text", "Frame batching improves OCR")
+    store.assert_triple(tx1, "pattern:frame-batch", "related_to", "concept:ocr", "ref")
+    store.assert_triple(tx1, "session:2026-03-01T09:00", "summary", "Debugging OCR pipeline")
+    store.assert_triple(tx1, "session:2026-03-01T09:00", "related_to", "concept:ocr", "ref")
+    store._tx1 = tx1  # stash for tests
+    return store
+
+
+class TestTransactions:
+    def test_begin_tx_returns_positive_id(self, store):
+        tx = store.begin_tx("test")
+        assert tx > 0
+
+    def test_latest_tx_empty_store(self, tmp_path):
+        s = TripleStore(str(tmp_path / "empty.db"))
+        assert s.latest_tx() == 0
+        s.close()
+
+    def test_latest_tx_after_writes(self, store):
+        tx1 = store.begin_tx("a")
+        tx2 = store.begin_tx("b")
+        assert store.latest_tx() == tx2
+        assert tx2 > tx1
+
+    def test_tx_metadata(self, store):
+        tx = store.begin_tx("test", metadata={"foo": "bar"})
+        row = store._conn.execute(
+            "SELECT metadata FROM transactions WHERE tx_id = ?", (tx,)
+        ).fetchone()
+        import json
+        assert json.loads(row["metadata"]) == {"foo": "bar"}
+
+    def test_tx_parent(self, store):
+        tx1 = store.begin_tx("parent")
+        tx2 = store.begin_tx("child", parent_tx=tx1)
+        row = store._conn.execute(
+            "SELECT parent_tx FROM transactions WHERE tx_id = ?", (tx2,)
+        ).fetchone()
+        assert row["parent_tx"] == tx1
+
+
+class TestAssertAndEntity:
+    def test_assert_returns_id(self, store):
+        tx = store.begin_tx("test")
+        tid = store.assert_triple(tx, "e:1", "name", "Test")
+        assert tid > 0
+
+    def test_entity_returns_all_attrs(self, populated_store):
+        ent = populated_store.entity("signal:2026-03-01T10:00")
+        assert ent["description"] == ["OCR stall"]
+        assert ent["priority"] == ["high"]
+        assert ent["related_to"] == ["concept:ocr"]
+
+    def test_entity_missing_returns_empty(self, store):
+        assert store.entity("nonexistent:1") == {}
+
+    def test_multiple_values_per_attr(self, store):
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, "e:1", "tag", "alpha")
+        store.assert_triple(tx, "e:1", "tag", "beta")
+        ent = store.entity("e:1")
+        assert set(ent["tag"]) == {"alpha", "beta"}
+
+    def test_entity_type_auto_populated(self, store):
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, "signal:abc", "x", "y")
+        row = store._conn.execute(
+            "SELECT entity_type FROM entity_types WHERE entity_id = ?",
+            ("signal:abc",),
+        ).fetchone()
+        assert row["entity_type"] == "signal"
+
+
+class TestRetraction:
+    def test_retract_by_attr(self, populated_store):
+        tx2 = populated_store.begin_tx("retract")
+        count = populated_store.retract_triple(tx2, "signal:2026-03-01T10:00", "priority")
+        assert count == 1
+        ent = populated_store.entity("signal:2026-03-01T10:00")
+        assert "priority" not in ent
+
+    def test_retract_by_attr_and_value(self, store):
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, "e:1", "tag", "a")
+        store.assert_triple(tx, "e:1", "tag", "b")
+        tx2 = store.begin_tx("retract")
+        count = store.retract_triple(tx2, "e:1", "tag", "a")
+        assert count == 1
+        ent = store.entity("e:1")
+        assert ent["tag"] == ["b"]
+
+    def test_retract_nonexistent_returns_zero(self, store):
+        tx = store.begin_tx("test")
+        count = store.retract_triple(tx, "e:nope", "attr")
+        assert count == 0
+
+
+class TestEAVTAsOfTx:
+    def test_as_of_tx_sees_old_state(self, populated_store):
+        tx1 = populated_store._tx1
+        tx2 = populated_store.begin_tx("change")
+        populated_store.retract_triple(tx2, "signal:2026-03-01T10:00", "priority")
+
+        # Current state: no priority
+        assert "priority" not in populated_store.entity("signal:2026-03-01T10:00")
+        # as_of tx1: has priority
+        assert "priority" in populated_store.entity("signal:2026-03-01T10:00", as_of_tx=tx1)
+
+
+class TestAEVT:
+    def test_entities_with_attr(self, populated_store):
+        results = populated_store.entities_with_attr("name")
+        assert ("concept:ocr", "OCR") in results
+
+    def test_entities_with_attr_multiple(self, populated_store):
+        results = populated_store.entities_with_attr("related_to")
+        eids = [r[0] for r in results]
+        assert "signal:2026-03-01T10:00" in eids
+        assert "pattern:frame-batch" in eids
+
+
+class TestVAET:
+    def test_backrefs(self, populated_store):
+        refs = populated_store.backrefs("concept:ocr")
+        eids = [r[0] for r in refs]
+        assert "signal:2026-03-01T10:00" in eids
+        assert "pattern:frame-batch" in eids
+        assert "session:2026-03-01T09:00" in eids
+
+    def test_backrefs_with_attribute_filter(self, populated_store):
+        refs = populated_store.backrefs("concept:ocr", attribute="related_to")
+        eids = [r[0] for r in refs]
+        assert "signal:2026-03-01T10:00" in eids
+
+    def test_backrefs_no_results(self, store):
+        assert store.backrefs("nonexistent:1") == []
+
+
+class TestAVET:
+    def test_lookup(self, populated_store):
+        found = populated_store.lookup("name", "OCR")
+        assert "concept:ocr" in found
+
+    def test_lookup_no_match(self, populated_store):
+        found = populated_store.lookup("name", "nonexistent")
+        assert found == []
+
+
+class TestNeighbors:
+    def test_neighbors_depth_1(self, populated_store):
+        nbrs = populated_store.neighbors("concept:ocr", depth=1)
+        assert "concept:ocr" in nbrs
+        # Should find signal, pattern, and session via backrefs
+        found_eids = set(nbrs.keys())
+        assert "signal:2026-03-01T10:00" in found_eids or "pattern:frame-batch" in found_eids
+
+    def test_neighbors_depth_0(self, populated_store):
+        nbrs = populated_store.neighbors("concept:ocr", depth=0)
+        assert "concept:ocr" in nbrs
+        assert len(nbrs) == 1  # only the entity itself
+
+
+class TestNovelty:
+    def test_novelty_after_tx(self, populated_store):
+        tx1 = populated_store._tx1
+        tx2 = populated_store.begin_tx("new")
+        populated_store.assert_triple(tx2, "concept:new", "name", "New Concept")
+        changes = populated_store.novelty(tx1)
+        assert len(changes) >= 1
+        assert any(c["entity_id"] == "concept:new" for c in changes)
+
+    def test_novelty_bounded(self, populated_store):
+        tx1 = populated_store._tx1
+        tx2 = populated_store.begin_tx("a")
+        populated_store.assert_triple(tx2, "concept:a", "name", "A")
+        tx3 = populated_store.begin_tx("b")
+        populated_store.assert_triple(tx3, "concept:b", "name", "B")
+        # Only changes between tx1 and tx2
+        changes = populated_store.novelty(tx1, until_tx=tx2)
+        eids = [c["entity_id"] for c in changes]
+        assert "concept:a" in eids
+        assert "concept:b" not in eids
+
+    def test_novelty_empty(self, store):
+        tx = store.begin_tx("test")
+        assert store.novelty(tx) == []
+
+
+class TestGC:
+    def test_gc_deletes_old_retracted(self, store):
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, "e:1", "x", "y")
+        tx2 = store.begin_tx("retract")
+        store.retract_triple(tx2, "e:1", "x")
+        # GC with 0 days should delete it
+        count = store.gc(older_than_days=0)
+        assert count >= 1
+
+    def test_gc_preserves_active(self, store):
+        tx = store.begin_tx("test")
+        store.assert_triple(tx, "e:1", "x", "y")
+        count = store.gc(older_than_days=0)
+        assert count == 0  # not retracted, shouldn't be deleted
+
+
+class TestStats:
+    def test_stats_populated(self, populated_store):
+        s = populated_store.stats()
+        assert s["triples"] >= 8
+        assert s["entities"] >= 4
+        assert s["transactions"] >= 1
+        assert s["db_size_bytes"] > 0
+
+    def test_stats_empty(self, store):
+        s = store.stats()
+        assert s["triples"] == 0
+        assert s["entities"] == 0
+        assert s["transactions"] == 0
+
+
+class TestWALMode:
+    def test_wal_mode_enabled(self, store):
+        mode = store._conn.execute("PRAGMA journal_mode").fetchone()[0]
+        assert mode == "wal"