nexo-brain 2.1.0 → 2.2.0

package/tests/test_cognitive 2.py

@@ -0,0 +1,205 @@
+"""Tests for cognitive engine: embeddings, cosine similarity, search, KG boost, decay."""
+
+import math
+import numpy as np
+
+
+def test_cosine_similarity_identical():
+    """Identical vectors should have similarity 1.0."""
+    import cognitive
+    a = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    assert abs(cognitive.cosine_similarity(a, a) - 1.0) < 1e-6
+
+
+def test_cosine_similarity_orthogonal():
+    """Orthogonal vectors should have similarity 0.0."""
+    import cognitive
+    a = np.array([1.0, 0.0, 0.0], dtype=np.float32)
+    b = np.array([0.0, 1.0, 0.0], dtype=np.float32)
+    assert abs(cognitive.cosine_similarity(a, b)) < 1e-6
+
+
+def test_cosine_similarity_zero_norm():
+    """Zero vector should return 0.0 (not NaN)."""
+    import cognitive
+    a = np.zeros(3, dtype=np.float32)
+    b = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+    assert cognitive.cosine_similarity(a, b) == 0.0
+    assert cognitive.cosine_similarity(b, a) == 0.0
+
+
+def test_blob_roundtrip():
+    """Array → blob → array should be lossless."""
+    import cognitive
+    arr = np.random.randn(768).astype(np.float32)
+    blob = cognitive._array_to_blob(arr)
+    recovered = cognitive._blob_to_array(blob)
+    np.testing.assert_array_equal(arr, recovered)
+
+
+def test_kg_boost_results_no_kg_data():
+    """KG boost should be a no-op when there are no KG nodes."""
+    import cognitive
+    results = [
+        {"source_type": "learning", "source_id": "L999", "score": 0.7},
+        {"source_type": "sensory", "source_id": "buffer#1", "score": 0.6},
+    ]
+    boosted = cognitive._kg_boost_results(results)
+    # No KG nodes in test DB → no boost applied
+    assert boosted[0]["score"] == 0.7
+    assert boosted[1]["score"] == 0.6
+    assert "kg_boost" not in boosted[0]
+
+
+def test_kg_boost_results_with_connections():
+    """KG boost should increase scores for connected nodes."""
+    import cognitive
+    import knowledge_graph as kg
+
+    db = cognitive._get_db()
+    # Initialize KG tables
+    db.executescript("""
+        CREATE TABLE IF NOT EXISTS kg_nodes (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            node_type TEXT NOT NULL,
+            node_ref TEXT NOT NULL UNIQUE,
+            label TEXT NOT NULL DEFAULT '',
+            properties TEXT DEFAULT '{}'
+        );
+        CREATE TABLE IF NOT EXISTS kg_edges (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_id INTEGER NOT NULL,
+            target_id INTEGER NOT NULL,
+            relation TEXT NOT NULL DEFAULT '',
+            weight REAL DEFAULT 1.0,
+            confidence REAL DEFAULT 1.0,
+            valid_from TEXT,
+            valid_until TEXT,
+            source_memory_id TEXT DEFAULT '',
+            properties TEXT DEFAULT '{}'
+        );
+    """)
+
+    # Create a learning node with 8 connections
+    node_id = db.execute(
+        "INSERT INTO kg_nodes (node_type, node_ref, label) VALUES (?, ?, ?)",
+        ("learning", "learning:42", "Test Learning")
+    ).lastrowid
+
+    for i in range(8):
+        file_id = db.execute(
+            "INSERT INTO kg_nodes (node_type, node_ref, label) VALUES (?, ?, ?)",
+            ("file", f"file:test{i}.py", f"test{i}.py")
+        ).lastrowid
+        db.execute(
+            "INSERT INTO kg_edges (source_id, target_id, relation, weight) VALUES (?, ?, ?, ?)",
+            (node_id, file_id, "touched", 1.0)
+        )
+    db.commit()
+
+    results = [
+        {"source_type": "learning", "source_id": "L42", "score": 0.6},
+        {"source_type": "sensory", "source_id": "buffer#1", "score": 0.6},
+    ]
+    boosted = cognitive._kg_boost_results(results)
+
+    # Learning with 8 edges should get boost
+    assert boosted[0].get("kg_boost") is not None
+    assert boosted[0]["score"] > 0.6
+    expected_boost = min(0.08, 0.015 * math.log2(8 + 1))
+    assert abs(boosted[0]["kg_boost"] - round(expected_boost, 4)) < 0.001
+
+    # Sensory with no KG node should NOT get boost
+    assert "kg_boost" not in boosted[1]
+
+
+def test_kg_boost_relevance_gate():
+    """KG boost should not apply to low-relevance results (score < 0.45)."""
+    import cognitive
+
+    db = cognitive._get_db()
+    db.executescript("""
+        CREATE TABLE IF NOT EXISTS kg_nodes (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            node_type TEXT NOT NULL,
+            node_ref TEXT NOT NULL UNIQUE,
+            label TEXT NOT NULL DEFAULT '',
+            properties TEXT DEFAULT '{}'
+        );
+        CREATE TABLE IF NOT EXISTS kg_edges (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            source_id INTEGER NOT NULL,
+            target_id INTEGER NOT NULL,
+            relation TEXT NOT NULL DEFAULT '',
+            weight REAL DEFAULT 1.0,
+            confidence REAL DEFAULT 1.0,
+            valid_from TEXT,
+            valid_until TEXT,
+            source_memory_id TEXT DEFAULT '',
+            properties TEXT DEFAULT '{}'
+        );
+    """)
+
+    node_id = db.execute(
+        "INSERT INTO kg_nodes (node_type, node_ref, label) VALUES (?, ?, ?)",
+        ("learning", "learning:99", "Low Score Learning")
+    ).lastrowid
+    for i in range(20):
+        fid = db.execute(
+            "INSERT INTO kg_nodes (node_type, node_ref, label) VALUES (?, ?, ?)",
+            ("file", f"file:low{i}.py", f"low{i}.py")
+        ).lastrowid
+        db.execute(
+            "INSERT INTO kg_edges (source_id, target_id, relation, weight) VALUES (?, ?, ?, ?)",
+            (node_id, fid, "touched", 1.0)
+        )
+    db.commit()
+
+    results = [
+        {"source_type": "learning", "source_id": "L99", "score": 0.3},
+    ]
+    boosted = cognitive._kg_boost_results(results)
+    # Score below 0.45 gate → no boost
+    assert boosted[0]["score"] == 0.3
+    assert "kg_boost" not in boosted[0]
+
+
+def test_decay_formula():
+    """Ebbinghaus decay should reduce strength over time (lambda operates on HOURS)."""
+    import cognitive
+    # STM decay: lambda=0.004126, after 7 days (168h) strength should be ~0.5
+    initial = 1.0
+    hours_7d = 7 * 24
+    decayed = initial * math.exp(-cognitive.LAMBDA_STM * hours_7d)
+    assert 0.45 < decayed < 0.55
+
+    # LTM decay: lambda=0.000481, after 60 days (1440h) strength should be ~0.5
+    hours_60d = 60 * 24
+    decayed_ltm = initial * math.exp(-cognitive.LAMBDA_LTM * hours_60d)
+    assert 0.45 < decayed_ltm < 0.55
+
+
+def test_apply_temporal_boost_historical():
+    """Historical queries should get no temporal boost."""
+    import cognitive
+    results = [
+        {"source_type": "learning", "source_id": "L1", "score": 0.7,
+         "created_at": "2026-03-28T10:00:00"},
+    ]
+    boosted = cognitive._apply_temporal_boost(results, "what happened months ago")
+    # Historical cue "months" should disable boost
+    assert boosted[0]["score"] == 0.7
+
+
+def test_apply_temporal_boost_operational():
+    """Operational queries should get a higher temporal boost."""
+    import cognitive
+    from datetime import datetime
+    now_str = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+    results = [
+        {"source_type": "learning", "source_id": "L1", "score": 0.7,
+         "created_at": now_str},
+    ]
+    boosted = cognitive._apply_temporal_boost(results, "active backend issues today")
+    # Very recent + operational → should get noticeable boost
+    assert boosted[0]["score"] > 0.7

package/tests/test_knowledge_graph 2.py

@@ -0,0 +1,140 @@
+"""Tests for Knowledge Graph operations."""
+
+
+def test_upsert_and_get_node():
+    """Create a node and retrieve it."""
+    import cognitive
+    cognitive._get_db()  # Ensure KG tables exist
+
+    import knowledge_graph as kg
+    node_id = kg.upsert_node("area", "area:test", "Test Area", {"color": "blue"})
+    assert node_id > 0
+
+    node = kg.get_node("area", "area:test")
+    assert node is not None
+    assert node["label"] == "Test Area"
+
+    # Upsert same node should return same id (update)
+    node_id2 = kg.upsert_node("area", "area:test", "Test Area Updated")
+    assert node_id2 == node_id
+
+    node2 = kg.get_node("area", "area:test")
+    assert node2["label"] == "Test Area Updated"
+
+
+def test_upsert_and_get_edge():
+    """Create nodes and edges, verify traversal."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    kg.upsert_node("learning", "learning:1", "L1")
+    kg.upsert_node("file", "file:foo.py", "foo.py")
+
+    result = kg.upsert_edge(
+        "learning", "learning:1", "touched",
+        "file", "file:foo.py", weight=1.0,
+    )
+    assert result["action"] == "ADD"
+
+    # Same edge again → NOOP
+    result2 = kg.upsert_edge(
+        "learning", "learning:1", "touched",
+        "file", "file:foo.py", weight=1.0,
+    )
+    assert result2["action"] == "NOOP"
+
+    # Different weight → UPDATE (closes old, creates new)
+    result3 = kg.upsert_edge(
+        "learning", "learning:1", "touched",
+        "file", "file:foo.py", weight=0.5,
+    )
+    assert result3["action"] == "UPDATE"
+
+
+def test_neighbors():
+    """Get direct neighbors of a node."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    kg.upsert_node("area", "area:myproject", "MyProject")
+    kg.upsert_node("learning", "learning:10", "L10")
+    kg.upsert_node("learning", "learning:11", "L11")
+    kg.upsert_edge("learning", "learning:10", "belongs_to", "area", "area:myproject")
+    kg.upsert_edge("learning", "learning:11", "belongs_to", "area", "area:myproject")
+
+    area_node = kg.get_node("area", "area:myproject")
+    neighbors = kg.get_neighbors(area_node["id"])
+    assert len(neighbors) == 2
+
+
+def test_traverse():
+    """BFS traversal from a node."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    # A → B → C chain
+    kg.upsert_node("area", "area:a", "A")
+    kg.upsert_node("file", "file:b", "B")
+    kg.upsert_node("change", "change:c", "C")
+    kg.upsert_edge("area", "area:a", "has", "file", "file:b")
+    kg.upsert_edge("file", "file:b", "modified_by", "change", "change:c")
+
+    a_node = kg.get_node("area", "area:a")
+    result = kg.traverse(a_node["id"], max_depth=2)
+    node_ids = {n["id"] for n in result["nodes"]}
+    # Should reach A, B, and C within depth 2
+    assert len(node_ids) == 3
+
+
+def test_shortest_path():
+    """Find shortest path between two nodes."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    kg.upsert_node("area", "area:x", "X")
+    kg.upsert_node("file", "file:y", "Y")
+    kg.upsert_node("change", "change:z", "Z")
+    kg.upsert_edge("area", "area:x", "has", "file", "file:y")
+    kg.upsert_edge("file", "file:y", "modified_by", "change", "change:z")
+
+    x = kg.get_node("area", "area:x")
+    z = kg.get_node("change", "change:z")
+    path = kg.shortest_path(x["id"], z["id"])
+    assert path is not None
+    assert len(path) == 3  # X → Y → Z
+
+
+def test_delete_edge():
+    """Soft-delete an edge (set valid_until)."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    kg.upsert_node("area", "area:del", "Del")
+    kg.upsert_node("file", "file:del", "Del File")
+    kg.upsert_edge("area", "area:del", "has", "file", "file:del")
+
+    deleted = kg.delete_edge("area", "area:del", "has", "file", "file:del")
+    assert deleted is True
+
+    # After deletion, no active neighbors
+    node = kg.get_node("area", "area:del")
+    neighbors = kg.get_neighbors(node["id"], active_only=True)
+    assert len(neighbors) == 0
+
+
+def test_stats():
+    """Stats should return valid counts."""
+    import cognitive
+    cognitive._get_db()
+
+    import knowledge_graph as kg
+    kg.upsert_node("area", "area:stats", "Stats Test")
+    s = kg.stats()
+    assert s["nodes"] >= 1
+    assert isinstance(s["edges_active"], int)
+    assert isinstance(s["node_types"], dict)

package/tests/test_migrations 2.py

@@ -0,0 +1,137 @@
+"""Tests for database schema and migrations."""
+
+import db as db_mod
+
+
+def test_init_db_creates_core_tables():
+    """All core tables should exist after init_db."""
+    conn = db_mod.get_db()
+    rows = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
+    ).fetchall()
+    tables = {r["name"] for r in rows}
+
+    expected = {
+        "sessions", "tracked_files", "messages", "message_reads",
+        "questions", "reminders", "followups", "learnings", "credentials",
+        "task_history", "task_frequencies", "plugins", "entities",
+        "preferences", "agents", "change_log", "decisions",
+    }
+    assert expected.issubset(tables), f"Missing tables: {expected - tables}"
+
+
+def test_migrations_idempotent():
+    """Running migrations twice should not raise."""
+    db_mod.run_migrations()
+    db_mod.run_migrations()
+    version = db_mod.get_schema_version()
+    assert version >= 1
+
+
+def test_session_crud():
+    """Register, update, and clean sessions."""
+    info = db_mod.register_session("test-sid-1", "test task")
+    assert info["sid"] == "test-sid-1"
+
+    active = db_mod.get_active_sessions()
+    sids = [s["sid"] for s in active]
+    assert "test-sid-1" in sids
+
+    db_mod.update_session("test-sid-1", "updated task")
+
+    db_mod.complete_session("test-sid-1")
+    active2 = db_mod.get_active_sessions()
+    sids2 = [s["sid"] for s in active2]
+    assert "test-sid-1" not in sids2
+
+
+def test_learning_crud():
+    """Create, search, update, and delete learnings."""
+    result = db_mod.create_learning(
+        category="test-cat",
+        title="Test Learning Title",
+        content="Some content about testing patterns.",
+    )
+    learning_id = result["id"]
+    assert learning_id > 0
+
+    found = db_mod.search_learnings("testing patterns")
+    assert any(l["id"] == learning_id for l in found)
+
+    db_mod.update_learning(learning_id, title="Updated Title")
+    found2 = db_mod.search_learnings("Updated Title")
+    assert any(l["id"] == learning_id for l in found2)
+
+    db_mod.delete_learning(learning_id)
+    found3 = db_mod.search_learnings("Updated Title")
+    assert not any(l["id"] == learning_id for l in found3)
+
+
+def test_reminder_followup_crud():
+    """Create and complete reminders and followups."""
+    db_mod.create_reminder("R-TEST1", "Test reminder", date="2026-12-31")
+    reminder = db_mod.get_reminder("R-TEST1")
+    assert reminder is not None
+    assert reminder["status"] == "PENDING"
+
+    db_mod.complete_reminder("R-TEST1")
+    reminder2 = db_mod.get_reminder("R-TEST1")
+    assert reminder2["status"] == "COMPLETED"
+
+    db_mod.create_followup("NF-TEST1", "Test followup", date="2026-12-31")
+    followup = db_mod.get_followup("NF-TEST1")
+    assert followup is not None
+
+    db_mod.complete_followup("NF-TEST1", result="done")
+    followup2 = db_mod.get_followup("NF-TEST1")
+    assert followup2["status"] == "COMPLETED"
+
+
+def test_recurring_followup():
+    """Recurring followup: complete archives with date suffix, creates new pending, returns correct IDs."""
+    db_mod.create_followup("NF-REC1", "Recurring test", date="2026-03-31", recurrence="weekly:monday")
+    followup = db_mod.get_followup("NF-REC1")
+    assert followup is not None
+    assert followup["recurrence"] == "weekly:monday"
+
+    result = db_mod.complete_followup("NF-REC1", result="done weekly")
+
+    # Result should reference the archived ID, not the recycled NF-REC1
+    assert result["status"] == "COMPLETED"
+    assert result["id"].startswith("NF-REC1-")  # archived with date suffix
+    assert result["next_id"] == "NF-REC1"
+    assert result["next_date"] is not None
+
+    # The new NF-REC1 should be PENDING (not the completed one)
+    new_followup = db_mod.get_followup("NF-REC1")
+    assert new_followup is not None
+    assert new_followup["status"] == "PENDING"
+
+    # The archived one should exist with date suffix
+    archived = db_mod.get_followup(result["id"])
+    assert archived is not None
+    assert archived["status"] == "COMPLETED"
+
+
+def test_credential_crud():
+    """Create, get, and delete credentials."""
+    db_mod.create_credential("test-service", "api_key", "secret123", notes="test")
+    creds = db_mod.get_credential("test-service", "api_key")
+    assert len(creds) == 1
+    assert creds[0]["value"] == "secret123"
+
+    db_mod.delete_credential("test-service", "api_key")
+    creds2 = db_mod.get_credential("test-service", "api_key")
+    assert len(creds2) == 0
+
+
+def test_fts_tables_created():
+    """FTS5 virtual tables should exist after init + migrations."""
+    conn = db_mod.get_db()
+    rows = conn.execute(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE '%fts%'"
+    ).fetchall()
+    # At minimum the learnings FTS should exist (created in init or migration)
+    table_names = {r["name"] for r in rows}
+    # nexo_fts is the main FTS table
+    assert "nexo_fts" in table_names or len(table_names) > 0