@geravant/sinain 1.13.0 → 1.15.0

package/sinain-memory/tests/test_triple_extractor.py

@@ -1,255 +0,0 @@
-"""Tests for triple_extractor.py — 3-tier extraction."""
-
-import pytest
-from triplestore import TripleStore
-from triple_extractor import TripleExtractor, Triple, _make_slug
-
-
-@pytest.fixture
-def store(tmp_path):
-    s = TripleStore(str(tmp_path / "test.db"))
-    yield s
-    s.close()
-
-
-@pytest.fixture
-def extractor(store):
-    return TripleExtractor(store)
-
-
-@pytest.fixture
-def store_with_vocab(store):
-    """Store pre-populated with concept vocabulary."""
-    tx = store.begin_tx("setup")
-    store.assert_triple(tx, "concept:ocr", "name", "OCR")
-    store.assert_triple(tx, "concept:flutter", "name", "Flutter")
-    store.assert_triple(tx, "concept:react-native", "name", "React Native")
-    return store
-
-
-# ----- Slug generation -----
-
-class TestMakeSlug:
-    def test_basic(self):
-        assert _make_slug("Frame Batching") == "frame-batching"
-
-    def test_special_chars(self):
-        assert _make_slug("OCR pipeline (v2.0)") == "ocr-pipeline-v2-0"
-
-    def test_leading_trailing(self):
-        assert _make_slug("  --hello--  ") == "hello"
-
-    def test_max_length(self):
-        long = "a" * 100
-        assert len(_make_slug(long)) <= 80
-
-    def test_empty(self):
-        assert _make_slug("") == ""
-        assert _make_slug("---") == ""
-
-
-# ----- Tier 1: Signal extraction -----
-
-class TestExtractSignal:
-    def test_basic_signal(self, extractor):
-        data = {
-            "sessionSummary": "Debugging OCR pipeline",
-            "idle": False,
-            "signals": [
-                {"description": "OCR pipeline backpressure", "priority": "high"}
-            ],
-            "recommendedAction": {"action": "sessions_spawn", "task": "Debug", "confidence": 0.8},
-            "output": {"suggestion": "Try frame batching", "insight": "Evening pattern"},
-        }
-        triples = extractor.extract_signal(data, "2026-03-01T10:00:00Z")
-
-        # Check entity creation
-        entity_attrs = {t.attribute for t in triples if t.entity_id == "signal:2026-03-01T10:00:00Z"}
-        assert "summary" in entity_attrs
-        assert "description" in entity_attrs
-        assert "priority" in entity_attrs
-        assert "action" in entity_attrs
-        assert "suggestion" in entity_attrs
-
-    def test_signal_with_playbook_changes(self, extractor):
-        data = {
-            "signals": [],
-            "playbookChanges": {
-                "changes": {"added": ["Use frame batching for OCR"], "pruned": [], "promoted": []}
-            },
-        }
-        triples = extractor.extract_signal(data, "2026-03-01")
-        pattern_triples = [t for t in triples if t.entity_id.startswith("pattern:")]
-        assert len(pattern_triples) > 0
-        assert any(t.attribute == "text" and "frame batching" in t.value.lower() for t in pattern_triples)
-
-    def test_signal_empty(self, extractor):
-        triples = extractor.extract_signal({"signals": []}, "2026-03-01")
-        assert isinstance(triples, list)
-
-    def test_signal_concepts_extracted(self, extractor):
-        data = {"signals": [{"description": "OCR Pipeline stall detected", "priority": "high"}]}
-        triples = extractor.extract_signal(data, "2026-03-01")
-        concept_triples = [t for t in triples if t.entity_id.startswith("concept:")]
-        assert len(concept_triples) > 0  # "OCR" or "Pipeline" should be extracted
-
-    def test_signal_concept_refs(self, extractor):
-        data = {"signals": [{"description": "React Native bridge crash", "priority": "high"}]}
-        triples = extractor.extract_signal(data, "2026-03-01")
-        ref_triples = [t for t in triples if t.value_type == "ref" and t.attribute == "related_to"]
-        assert len(ref_triples) > 0
-
-
-# ----- Tier 1: Session extraction -----
-
-class TestExtractSession:
-    def test_basic_session(self, extractor):
-        data = {
-            "ts": "2026-03-01T09:00:00Z",
-            "summary": "Implemented OCR batch processing",
-            "toolsUsed": ["Read", "Edit", "Bash"],
-            "durationMs": 120000,
-        }
-        triples = extractor.extract_session(data)
-
-        # Check session entity
-        session_triples = [t for t in triples if t.entity_id.startswith("session:")]
-        assert any(t.attribute == "summary" for t in session_triples)
-        assert any(t.attribute == "duration_ms" for t in session_triples)
-
-        # Check tool refs
-        tool_triples = [t for t in triples if t.entity_id.startswith("tool:")]
-        assert len(tool_triples) >= 3
-
-    def test_session_tool_refs(self, extractor):
-        data = {
-            "ts": "2026-03-01",
-            "toolsUsed": ["Bash"],
-        }
-        triples = extractor.extract_session(data)
-        ref_triples = [t for t in triples if t.value_type == "ref" and t.attribute == "used_tool"]
-        assert len(ref_triples) == 1
-
-
-# ----- Tier 1: Mining extraction -----
-
-class TestExtractMining:
-    def test_new_patterns(self, extractor):
-        data = {
-            "newPatterns": ["Frame dropping improves OCR accuracy", "Use batch processing"],
-            "preferences": ["User prefers minimal configs"],
-            "contradictions": [],
-        }
-        triples = extractor.extract_mining(data)
-        pattern_triples = [t for t in triples if t.attribute == "text"]
-        assert len(pattern_triples) >= 2
-
-    def test_mining_preferences(self, extractor):
-        data = {"newPatterns": [], "preferences": ["User likes concise output"]}
-        triples = extractor.extract_mining(data)
-        pref_triples = [t for t in triples if t.attribute == "pattern_type" and t.value == "preference"]
-        assert len(pref_triples) == 1
-
-    def test_mining_contradictions(self, extractor):
-        data = {"newPatterns": [], "contradictions": ["Playbook says X but observation shows Y"]}
-        triples = extractor.extract_mining(data)
-        contra = [t for t in triples if t.attribute == "pattern_type" and t.value == "contradiction"]
-        assert len(contra) == 1
-
-    def test_mining_empty(self, extractor):
-        triples = extractor.extract_mining({"newPatterns": [], "preferences": [], "contradictions": []})
-        assert triples == []
-
-
-# ----- Tier 2: Playbook extraction (regex) -----
-
-class TestExtractPlaybook:
-    def test_patterns_with_scores(self, extractor):
-        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 for new frameworks\n"
-        )
-        triples = extractor.extract_playbook(text)
-        text_triples = [t for t in triples if t.attribute == "text"]
-        assert len(text_triples) >= 3
-
-        score_triples = [t for t in triples if t.attribute == "score"]
-        assert len(score_triples) == 2
-        assert any(t.value == "0.8" for t in score_triples)
-
-    def test_skips_comments_and_metadata(self, extractor):
-        text = "- <!-- mining-index: 2026-02-21 -->\n- [since: 2026-02-18] stale entry\n- Real pattern here\n"
-        triples = extractor.extract_playbook(text)
-        text_triples = [t for t in triples if t.attribute == "text"]
-        # Should only get "Real pattern here"
-        assert any("Real pattern" in t.value for t in text_triples)
-        assert not any("mining-index" in t.value for t in text_triples)
-
-    def test_playbook_source_tagged(self, extractor):
-        text = "- Use batch processing\n"
-        triples = extractor.extract_playbook(text)
-        source_triples = [t for t in triples if t.attribute == "source"]
-        assert any(t.value == "playbook" for t in source_triples)
-
-
-# ----- Tier 2: Module extraction -----
-
-class TestExtractModule:
-    def test_module_manifest_and_patterns(self, extractor):
-        manifest = {
-            "name": "React Native Dev",
-            "description": "RN development patterns",
-            "version": "1.0.0",
-        }
-        patterns_text = "## Established\n- Use Hermes engine for Android\n- Enable Fast Refresh\n"
-        triples = extractor.extract_module("react-native-dev", manifest, patterns_text)
-
-        module_triples = [t for t in triples if t.entity_id == "module:react-native-dev"]
-        assert any(t.attribute == "name" and t.value == "React Native Dev" for t in module_triples)
-        assert any(t.attribute == "description" for t in module_triples)
-
-        # Patterns should link back to module
-        belongs_triples = [t for t in triples if t.attribute == "belongs_to" and t.value == "module:react-native-dev"]
-        assert len(belongs_triples) >= 2
-
-
-# ----- Concept extraction -----
-
-class TestExtractConcepts:
-    def test_vocab_cache_match(self, store_with_vocab):
-        extractor = TripleExtractor(store_with_vocab)
-        triples = extractor.extract_concepts("Working on OCR pipeline improvements")
-        concept_ids = {t.entity_id for t in triples}
-        assert "concept:ocr" in concept_ids
-
-    def test_regex_capitalized_phrases(self, extractor):
-        # Multi-word capitalized phrases get captured (including leading caps)
-        triples = extractor.extract_concepts("Debugging React Native bridge issues")
-        concept_ids = {t.entity_id for t in triples}
-        # "Debugging React Native" is captured as one phrase since all words are capitalized
-        assert any("react-native" in cid for cid in concept_ids)
-
-    def test_regex_acronyms(self, extractor):
-        triples = extractor.extract_concepts("The API uses JSON over HTTP")
-        concept_ids = {t.entity_id for t in triples}
-        assert any("api" in cid for cid in concept_ids)
-        assert any("json" in cid for cid in concept_ids)
-        assert any("http" in cid for cid in concept_ids)
-
-    def test_regex_technical_terms(self, extractor):
-        triples = extractor.extract_concepts("Check the frame-batching pipeline and error-handling logic")
-        concept_ids = {t.entity_id for t in triples}
-        assert "concept:frame-batching" in concept_ids
-        assert "concept:error-handling" in concept_ids
-
-    def test_short_text_no_llm(self, extractor):
-        # Short text should not trigger LLM fallback
-        triples = extractor.extract_concepts("Hello")
-        # Should return empty or just regex matches, no LLM call
-        assert isinstance(triples, list)
-
-    def test_empty_text(self, extractor):
-        triples = extractor.extract_concepts("")
-        assert triples == []

package/sinain-memory/tests/test_triple_ingest.py

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

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