nexo-brain 2.2.0 → 2.3.1

package/tests/conftest.py

@@ -1,71 +0,0 @@
-"""Shared fixtures for NEXO test suite.
-
-Uses isolated temp databases so tests never touch production data.
-"""
-
-import os
-import sys
-import sqlite3
-
-import pytest
-
-# Add src/ to path so we can import nexo modules
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "src"))
-
-
-@pytest.fixture(autouse=True)
-def isolated_db(tmp_path, monkeypatch):
-    """Redirect both nexo.db and cognitive.db to temp files per test."""
-    test_db = str(tmp_path / "test_nexo.db")
-    test_cog_db = str(tmp_path / "test_cognitive.db")
-
-    monkeypatch.setenv("NEXO_TEST_DB", test_db)
-    monkeypatch.setenv("NEXO_COGNITIVE_DB", test_cog_db)
-    monkeypatch.setenv("NEXO_SKIP_FS_INDEX", "1")
-
-    import db._core as db_core
-    import cognitive._core as cog_core
-
-    # Close existing connections
-    db_core.close_db()
-    if cog_core._conn is not None:
-        try:
-            cog_core._conn.close()
-        except Exception:
-            pass
-        cog_core._conn = None
-
-    # Point to temp paths
-    db_core.DB_PATH = test_db
-    cog_core.COGNITIVE_DB = test_cog_db
-
-    # Create a fresh raw connection
-    raw = sqlite3.connect(test_db, timeout=30, check_same_thread=False,
-                          isolation_level=None)
-    raw.execute("PRAGMA journal_mode=WAL")
-    raw.execute("PRAGMA busy_timeout=30000")
-    raw.execute("PRAGMA foreign_keys=ON")
-    raw.row_factory = sqlite3.Row
-
-    wrapped = db_core._SerializedConnection(raw)
-    db_core._shared_conn = wrapped
-
-    # Initialize schemas
-    from db._core import init_db
-    from db._schema import run_migrations
-    init_db()
-    run_migrations()
-
-    yield {
-        "nexo_db": test_db,
-        "cognitive_db": test_cog_db,
-    }
-
-    # Cleanup
-    db_core.close_db()
-    if cog_core._conn is not None:
-        try:
-            cog_core._conn.close()
-        except Exception:
-            pass
-        cog_core._conn = None

package/tests/test_cognitive 2.py

@@ -1,205 +0,0 @@
-"""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_cognitive.py

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

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