Initial commit: add .gitignore and README

tests/test_super_big_brain.py

@@ -0,0 +1,165 @@
+"""Tests for Super Big Brain: atomic decomposition, graph, recomposition."""
+
+import pytest
+
+from fusionagi.schemas.atomic import (
+    AtomicSemanticUnit,
+    AtomicUnitType,
+    DecompositionResult,
+    SemanticRelation,
+    RelationType,
+)
+from fusionagi.reasoning.decomposition import decompose_recursive
+from fusionagi.memory.semantic_graph import SemanticGraphMemory
+from fusionagi.memory.sharding import shard_context, Shard
+from fusionagi.reasoning.context_loader import load_context_for_reasoning, build_compact_prompt
+from fusionagi.memory.scratchpad import LatentScratchpad, ThoughtState
+from fusionagi.reasoning.tot import ThoughtNode, expand_node, prune_subtree, merge_subtrees
+from fusionagi.reasoning.multi_path import generate_and_score_parallel
+from fusionagi.reasoning.recomposition import recompose, RecomposedResponse
+from fusionagi.reasoning.meta_reasoning import challenge_assumptions, detect_contradictions, revisit_node
+from fusionagi.core.super_big_brain import (
+    run_super_big_brain,
+    SuperBigBrainConfig,
+    SuperBigBrainReasoningProvider,
+)
+from fusionagi.schemas.head import HeadId
+
+
+class TestAtomicSchema:
+    """Test atomic semantic unit schemas."""
+
+    def test_atomic_unit_creation(self):
+        u = AtomicSemanticUnit(
+            unit_id="asu_1",
+            content="Test fact",
+            type=AtomicUnitType.FACT,
+            confidence=0.9,
+        )
+        assert u.unit_id == "asu_1"
+        assert u.content == "Test fact"
+        assert u.type == AtomicUnitType.FACT
+        assert u.confidence == 0.9
+
+    def test_decomposition_result(self):
+        u = AtomicSemanticUnit(unit_id="asu_1", content="Fact", type=AtomicUnitType.FACT)
+        r = SemanticRelation(from_id="root", to_id="asu_1", relation_type=RelationType.LOGICAL)
+        result = DecompositionResult(units=[u], relations=[r], depth=0)
+        assert len(result.units) == 1
+        assert len(result.relations) == 1
+        assert result.depth == 0
+
+
+class TestDecomposition:
+    """Test recursive decomposition."""
+
+    def test_decompose_simple(self):
+        result = decompose_recursive("What are the security risks? Must support 1M users.")
+        assert len(result.units) >= 1
+        assert result.depth >= 0
+
+    def test_decompose_empty(self):
+        result = decompose_recursive("")
+        assert len(result.units) == 0
+
+    def test_decompose_max_depth(self):
+        result = decompose_recursive("Question one? Question two? Question three?", max_depth=1)
+        assert result.depth <= 1
+
+
+class TestSemanticGraph:
+    """Test semantic graph memory."""
+
+    def test_add_and_query(self):
+        g = SemanticGraphMemory()
+        u = AtomicSemanticUnit(unit_id="asu_1", content="Fact", type=AtomicUnitType.FACT)
+        g.add_unit(u)
+        assert g.get_unit("asu_1") == u
+        assert len(g.query_units()) >= 1
+
+    def test_ingest_decomposition(self):
+        g = SemanticGraphMemory()
+        r = decompose_recursive("What is X? Constraint: must be fast.")
+        g.ingest_decomposition(r.units, r.relations)
+        assert len(g.query_units()) >= 1
+
+
+class TestSharding:
+    """Test context sharding."""
+
+    def test_shard_context(self):
+        r = decompose_recursive("Security risk? Cost constraint?")
+        shards = shard_context(r.units, max_cluster_size=5)
+        assert isinstance(shards, list)
+        assert all(isinstance(s, Shard) for s in shards)
+
+
+class TestContextLoader:
+    """Test retrieve-by-reference."""
+
+    def test_load_context(self):
+        r = decompose_recursive("Test prompt")
+        ctx = load_context_for_reasoning(r.units)
+        assert "unit_refs" in ctx
+        assert "unit_summaries" in ctx
+
+    def test_build_compact_prompt(self):
+        r = decompose_recursive("Short prompt")
+        prompt = build_compact_prompt(r.units, max_chars=1000)
+        assert isinstance(prompt, str)
+
+
+class TestScratchpad:
+    """Test latent scratchpad."""
+
+    def test_append_and_get(self):
+        s = LatentScratchpad()
+        s.append_hypothesis("H1")
+        s.append_discarded("D1")
+        state = s.get_intermediate()
+        assert len(state.hypotheses) == 1
+        assert len(state.discarded_paths) == 1
+
+    def test_clear(self):
+        s = LatentScratchpad()
+        s.append_hypothesis("H1")
+        s.clear()
+        state = s.get_intermediate()
+        assert len(state.hypotheses) == 0
+
+
+class TestMetaReasoning:
+    """Test meta-reasoning hooks."""
+
+    def test_challenge_assumptions(self):
+        u = AtomicSemanticUnit(
+            unit_id="asu_1",
+            content="Assume X is true",
+            type=AtomicUnitType.ASSUMPTION,
+        )
+        flagged = challenge_assumptions([u], "Conclusion based on X")
+        assert len(flagged) >= 0
+
+    def test_detect_contradictions(self):
+        u1 = AtomicSemanticUnit(unit_id="a", content="X is true", type=AtomicUnitType.FACT)
+        u2 = AtomicSemanticUnit(unit_id="b", content="X is not true", type=AtomicUnitType.FACT)
+        pairs = detect_contradictions([u1, u2])
+        assert isinstance(pairs, list)
+
+
+class TestSuperBigBrain:
+    """Test Super Big Brain orchestrator."""
+
+    def test_run_super_big_brain(self):
+        g = SemanticGraphMemory()
+        r = run_super_big_brain("What are the risks?", g)
+        assert isinstance(r, RecomposedResponse)
+        assert r.summary
+        assert 0 <= r.confidence <= 1
+
+    def test_super_big_brain_reasoning_provider(self):
+        p = SuperBigBrainReasoningProvider()
+        ho = p.produce_head_output(HeadId.LOGIC, "Analyze architecture")
+        assert ho.head_id == HeadId.LOGIC
+        assert ho.summary
+        assert len(ho.claims) >= 0