nucleus-mcp 1.0.7 → 1.2.0

package/src/mcp_server_nucleus/tool_tiers.py

@@ -1,243 +0,0 @@
-"""
-Nucleus Tool Tier System - Registry Bloat Solution
-
-Solves the "137 tools crash LLM client" problem by organizing tools into tiers:
-- Tier 0 (LAUNCH): 5 essential tools for nucleusos.dev demo
-- Tier 1 (CORE): 20 standard operation tools
-- Tier 2 (ADVANCED): All 137 tools
-
-Set NUCLEUS_TOOL_TIER environment variable to control which tier is active:
-- "0" or "launch": Only Tier 0 tools (default for website)
-- "1" or "core": Tier 0 + Tier 1 tools
-- "2" or "advanced" or "all": All tools
-
-Author: Nucleus Team
-Version: 0.6.0
-"""
-
-import os
-from typing import Set, Dict, Any
-
-# =============================================================================
-# TIER DEFINITIONS
-# =============================================================================
-
-TIER_0_LAUNCH: Set[str] = {
-    # The "Govern Your Agents in 60 Seconds" story
-    "brain_write_engram",        # Persist a memory
-    "brain_query_engrams",       # Retrieve memories
-    "brain_search_engrams",      # Substring search (v0.6.0)
-    "brain_audit_log",           # Trust verification (SHA-256 ledger)
-    "brain_mount_server",        # Recursive aggregation demo (TEASER ONLY - Limited)
-    # Meta tools
-    "brain_version",             # Version check
-    "brain_health",              # Health check
-    "brain_list_tools",          # Discover available tools
-    # Governance Demo Tools
-    "nucleus_list_directory",    # Demo A: Inspect environment
-    "nucleus_delete_file",       # Demo A: Test protection
-    "lock_resource",             # Demo A: Block modification
-    "unlock_resource",           # Demo A: Allow modification
-    "hypervisor_status",         # Demo A: Status check
-    "watch_resource",            # Demo A: Monitor changes
-}
-
-TIER_1_CORE: Set[str] = {
-    # Task Management
-    "brain_list_tasks",
-    "brain_get_next_task",
-    "brain_add_task",
-    "brain_update_task",
-    "brain_claim_task",
-    # Orchestration
-    "brain_orchestrate",
-    "brain_spawn_agent",
-    "brain_slot_complete",
-    # State & Status
-    "brain_get_state",
-    "brain_update_state",
-    "brain_dashboard",
-    "brain_status_dashboard",
-    # DSoR
-    "brain_dsor_status",
-    "brain_list_decisions",
-    "brain_metering_summary",
-    "brain_ipc_tokens",
-    # Sessions
-    "brain_session_start",
-    "brain_save_session",
-    "brain_list_sessions",
-    # Memory
-    "brain_read_memory",
-    "brain_search_memory",
-    # Multi-Agent Sync (v0.7.0)
-    "brain_sync_status",
-    "brain_sync_now",
-    "brain_sync_auto",
-    "brain_sync_auto",
-    "brain_identify_agent",
-    # Hypervisor (v0.8.0)
-    "lock_resource",
-    "unlock_resource",
-    "watch_resource",
-    "hypervisor_status",
-    "set_hypervisor_mode",
-}
-
-TIER_2_ADVANCED: Set[str] = {
-    # Federation
-    "brain_federation_status",
-    "brain_federation_join",
-    "brain_federation_leave",
-    "brain_federation_peers",
-    "brain_federation_sync",
-    "brain_federation_route",
-    "brain_federation_health",
-    "brain_federation_dsor_status",
-    "brain_routing_decisions",
-    # Depth Management
-    "brain_depth_map",
-    "brain_depth_push",
-    "brain_depth_pop",
-    "brain_depth_show",
-    "brain_depth_reset",
-    "brain_depth_set_max",
-    # Autopilot
-    "brain_autopilot_sprint",
-    "brain_autopilot_sprint_v2",
-    "brain_halt_sprint",
-    "brain_resume_sprint",
-    # Ingestion
-    "brain_ingest_tasks",
-    "brain_ingestion_stats",
-    "brain_rollback_ingestion",
-    "brain_import_tasks_from_jsonl",
-    # Features
-    "brain_add_feature",
-    "brain_get_feature",
-    "brain_list_features",
-    "brain_update_feature",
-    "brain_search_features",
-    # Artifacts
-    "brain_write_artifact",
-    "brain_read_artifact",
-    "brain_list_artifacts",
-    # Proofs
-    "brain_generate_proof",
-    "brain_get_proof",
-    "brain_list_proofs",
-    # Everything else is implicitly Tier 2
-}
-
-# =============================================================================
-# TIER RESOLUTION
-# =============================================================================
-
-# Global cache for the active tier to avoid repeated lookups during import
-_ACTIVE_TIER_CACHE = None
-
-def get_active_tier() -> int:
-    """Determine the active tier based on environment variables."""
-    global _ACTIVE_TIER_CACHE
-    if _ACTIVE_TIER_CACHE is not None:
-        return _ACTIVE_TIER_CACHE
-        
-    # Security through Obscurity (v0.6.0 Friction)
-    # Prevents casual users from flipping a simple '1' switch.
-    # Hackers who read source will find this. That is acceptable marketing.
-    beta_token = os.environ.get("NUCLEUS_BETA_TOKEN", "").strip()
-    
-    if beta_token == "sovereign-launch-alpha":
-        _ACTIVE_TIER_CACHE = 1  # Unlock Manager Suite
-    elif beta_token == "titan-sovereign-godmode":
-        _ACTIVE_TIER_CACHE = 2  # Unlock Everything
-    else:
-        _ACTIVE_TIER_CACHE = 0  # Default to Journal Mode
-        
-    return _ACTIVE_TIER_CACHE
-
-
-def get_allowed_tools() -> Set[str]:
-    """Get the set of tool names allowed for the current tier."""
-    tier = get_active_tier()
-    
-    if tier == 0:
-        return TIER_0_LAUNCH.copy()
-    elif tier == 1:
-        return TIER_0_LAUNCH | TIER_1_CORE
-    else:
-        # Tier 2 allows all tools
-        return None  # None means no filtering
-
-
-def is_tool_allowed(tool_name: str) -> bool:
-    """Check if a specific tool is allowed in the current tier."""
-    allowed = get_allowed_tools()
-    
-    if allowed is None:
-        return True  # Tier 2 allows all
-    
-    return tool_name in allowed
-
-
-def get_tier_info() -> Dict[str, Any]:
-    """Get information about current tier configuration."""
-    tier = get_active_tier()
-    allowed = get_allowed_tools()
-    
-    tier_names = {0: "LAUNCH", 1: "CORE", 2: "ADVANCED"}
-    
-    return {
-        "active_tier": tier,
-        "tier_name": tier_names.get(tier, "UNKNOWN"),
-        "tools_allowed": len(allowed) if allowed else "ALL",
-        "tier_0_count": len(TIER_0_LAUNCH),
-        "tier_1_count": len(TIER_1_CORE),
-        "tier_2_count": len(TIER_2_ADVANCED),
-        "env_var": "NUCLEUS_TOOL_TIER",
-        "current_value": os.environ.get("NUCLEUS_TOOL_TIER", "0"),
-    }
-
-
-# =============================================================================
-# TOOL REGISTRATION FILTER
-# =============================================================================
-
-class TierFilteredToolManager:
-    """
-    Manages tool registration with tier filtering.
-    
-    Usage:
-        manager = TierFilteredToolManager()
-        
-        @manager.register("brain_my_tool")
-        def brain_my_tool():
-            pass
-    """
-    
-    def __init__(self):
-        self.registered_tools: Set[str] = set()
-        self.filtered_tools: Set[str] = set()
-    
-    def should_register(self, tool_name: str) -> bool:
-        """Check if tool should be registered based on tier."""
-        allowed = is_tool_allowed(tool_name)
-        
-        if allowed:
-            self.registered_tools.add(tool_name)
-        else:
-            self.filtered_tools.add(tool_name)
-        
-        return allowed
-    
-    def get_stats(self) -> Dict[str, Any]:
-        """Get registration statistics."""
-        return {
-            "registered": len(self.registered_tools),
-            "filtered": len(self.filtered_tools),
-            "tier_info": get_tier_info(),
-        }
-
-
-# Global instance for use in __init__.py
-tier_manager = TierFilteredToolManager()

package/tests/__init__.py

@@ -1 +0,0 @@
-"""Nucleus MCP Tests"""

package/tests/conftest.py

@@ -1,42 +0,0 @@
-
-import pytest
-import os
-import tempfile
-import json
-from pathlib import Path
-from mcp_server_nucleus.runtime.common import get_brain_path
-
-@pytest.fixture
-def temp_brain():
-    """Create a temporary brain directory for testing."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        old_brain = os.environ.get("NUCLEAR_BRAIN_PATH")
-        os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-        
-        # Initialize structure
-        brain_path = Path(tmpdir)
-        (brain_path / "engrams").mkdir(parents=True, exist_ok=True)
-        (brain_path / "ledger").mkdir(parents=True, exist_ok=True)
-        
-        yield brain_path
-        
-        if old_brain:
-            os.environ["NUCLEAR_BRAIN_PATH"] = old_brain
-        else:
-            del os.environ["NUCLEAR_BRAIN_PATH"]
-
-@pytest.fixture
-def sample_engrams(temp_brain):
-    """Seed the brain with sample engrams."""
-    engram_path = temp_brain / "engrams" / "ledger.jsonl"
-    engrams = [
-        {"key": "db_choice", "value": "PostgreSQL", "context": "Architecture", "intensity": 8},
-        {"key": "ui_theme", "value": "Dark Mode", "context": "UI", "intensity": 5},
-        {"key": "api_key", "value": "SECRET", "context": "Security", "intensity": 10},
-    ]
-    
-    with open(engram_path, "w") as f:
-        for e in engrams:
-            f.write(json.dumps(e) + "\n")
-            
-    return engrams

package/tests/test_core.py

@@ -1,235 +0,0 @@
-"""
-Core tests for Nucleus MCP - Updated for v1.0.5 API
-"""
-
-import json
-import tempfile
-import os
-from pathlib import Path
-
-import pytest
-
-
-class TestBrainPath:
-    """Tests for brain path functionality."""
-    
-    def test_get_brain_path_requires_env(self):
-        """Test that brain path requires env var (v1.0+ behavior)."""
-        from mcp_server_nucleus import get_brain_path
-        
-        # Clear env var
-        old_val = os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-        
-        try:
-            with pytest.raises(ValueError):
-                get_brain_path()
-        finally:
-            if old_val:
-                os.environ["NUCLEAR_BRAIN_PATH"] = old_val
-    
-    def test_get_brain_path_from_env(self):
-        """Test brain path from environment variable."""
-        from mcp_server_nucleus import get_brain_path
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                path = get_brain_path()
-                assert path == Path(tmpdir)
-                assert path.exists()
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-class TestMakeResponse:
-    """Tests for response formatting."""
-    
-    def test_make_response_success(self):
-        """Test successful response format."""
-        from mcp_server_nucleus import make_response
-        
-        response = make_response(True, data={"key": "value"})
-        data = json.loads(response)
-        
-        assert data["success"] is True
-        assert data["data"]["key"] == "value"
-        assert "timestamp" in data
-    
-    def test_make_response_failure(self):
-        """Test failure response format."""
-        from mcp_server_nucleus import make_response
-        
-        response = make_response(False, error="Error message")
-        data = json.loads(response)
-        
-        assert data["success"] is False
-        assert data["error"] == "Error message"
-    
-    def test_make_response_with_error_code(self):
-        """Test response with error code."""
-        from mcp_server_nucleus import make_response
-        
-        response = make_response(False, error="Not found", error_code="ERR_NOT_FOUND")
-        data = json.loads(response)
-        
-        assert data["error_code"] == "ERR_NOT_FOUND"
-
-
-class TestStateManagement:
-    """Tests for state management."""
-    
-    def test_get_state_empty(self):
-        """Test getting state when empty."""
-        from mcp_server_nucleus import _get_state
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                state = _get_state()
-                assert state == {}
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-    
-    def test_update_state(self):
-        """Test updating state."""
-        from mcp_server_nucleus import _update_state, _get_state
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            # Create ledger directory
-            Path(tmpdir, "ledger").mkdir(parents=True, exist_ok=True)
-            
-            try:
-                result = _update_state({"test_key": "test_value"})
-                assert "successfully" in result.lower() or "error" not in result.lower()
-                
-                state = _get_state()
-                assert state.get("test_key") == "test_value"
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-class TestEventEmission:
-    """Tests for event logging."""
-    
-    def test_emit_event(self):
-        """Test event emission."""
-        from mcp_server_nucleus import _emit_event
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            # Create ledger directory (required for event writing)
-            Path(tmpdir, "ledger").mkdir(parents=True, exist_ok=True)
-            
-            try:
-                _emit_event("TEST_EVENT", "test_emitter", {"key": "value"})
-                
-                events_path = Path(tmpdir) / "ledger" / "events.jsonl"
-                assert events_path.exists()
-                
-                with open(events_path) as f:
-                    line = f.readline()
-                    event = json.loads(line)
-                
-                assert event["type"] == "TEST_EVENT"
-                assert event["data"]["key"] == "value"
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-class TestEngramTools:
-    """Tests for engram (memory) tools."""
-    
-    def test_write_and_query_engram(self):
-        """Test writing and querying engrams."""
-        from mcp_server_nucleus import _brain_write_engram_impl, _brain_query_engrams_impl
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                # Write an engram (context must be valid: Feature, Architecture, Brand, Strategy, Decision)
-                result = _brain_write_engram_impl(
-                    key="test_key",
-                    value="Test knowledge",
-                    context="Decision",
-                    intensity=5
-                )
-                data = json.loads(result)
-                assert data["success"] is True
-                assert "engram" in data["data"]
-                assert data["data"]["engram"]["key"] == "test_key"
-                
-                # Query engrams by context
-                result = _brain_query_engrams_impl(context="Decision", min_intensity=1)
-                data = json.loads(result)
-                assert data["success"] is True
-                assert len(data["data"]["engrams"]) > 0
-                assert "Test knowledge" in data["data"]["engrams"][0]["value"]
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-class TestSyncTools:
-    """Tests for sync functionality."""
-    
-    def test_identify_agent(self):
-        """Test agent identification."""
-        from mcp_server_nucleus import brain_identify_agent
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                # Call the public function directly
-                result = brain_identify_agent("test_agent", "cursor")
-                data = json.loads(result)
-                
-                # v1.0.5 returns flat structure with agent_id
-                assert data["agent_id"] == "test_agent"
-                assert data["environment"] == "cursor"
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-    
-    def test_sync_now(self):
-        """Test manual sync."""
-        from mcp_server_nucleus import brain_sync_now
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                result = brain_sync_now()
-                data = json.loads(result)
-                
-                # Returns error when sync not enabled (expected behavior)
-                assert "error" in data or "status" in data or "success" in data
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-class TestHealthCheck:
-    """Tests for health check."""
-    
-    def test_brain_health(self):
-        """Test brain health check."""
-        from mcp_server_nucleus import _brain_health_impl
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-            
-            try:
-                result = _brain_health_impl()
-                data = json.loads(result)
-                
-                # v1.0.5 returns flat structure with status
-                assert "status" in data
-                assert "uptime_seconds" in data
-            finally:
-                os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])

package/tests/test_search.py

@@ -1,69 +0,0 @@
-"""
-Search tests for Nucleus MCP - Updated for v1.0.5 API
-
-Note: The current API queries by context and min_intensity, not by keyword.
-"""
-
-import json
-import os
-import tempfile
-
-import pytest
-from mcp_server_nucleus import _brain_query_engrams_impl, _brain_write_engram_impl
-
-
-@pytest.fixture
-def temp_brain():
-    """Create a temporary brain directory."""
-    with tempfile.TemporaryDirectory() as tmpdir:
-        os.environ["NUCLEAR_BRAIN_PATH"] = tmpdir
-        yield tmpdir
-        os.environ.pop("NUCLEAR_BRAIN_PATH", None)
-
-
-@pytest.fixture
-def sample_engrams(temp_brain):
-    """Create sample engrams for testing."""
-    engrams = [
-        ("db_choice", "PostgreSQL for ACID compliance", "Architecture", 8),
-        ("api_key", "SECRET_KEY_12345", "Decision", 5),
-        ("design_pattern", "Use factory pattern", "Architecture", 6),
-    ]
-    for key, value, context, intensity in engrams:
-        _brain_write_engram_impl(key, value, context, intensity)
-    return engrams
-
-
-def test_brain_query_by_context(temp_brain, sample_engrams):
-    """Test querying engrams by context."""
-    
-    # Query Architecture context
-    res_str = _brain_query_engrams_impl(context="Architecture", min_intensity=1)
-    res = json.loads(res_str)
-    assert res["success"] is True
-    assert res["data"]["count"] == 2  # db_choice and design_pattern
-    
-    # Query Decision context
-    res_str = _brain_query_engrams_impl(context="Decision", min_intensity=1)
-    res = json.loads(res_str)
-    assert res["success"] is True
-    assert res["data"]["count"] == 1  # api_key
-
-
-def test_brain_query_by_intensity(temp_brain, sample_engrams):
-    """Test filtering engrams by minimum intensity."""
-    
-    # High intensity only
-    res_str = _brain_query_engrams_impl(context="Architecture", min_intensity=7)
-    res = json.loads(res_str)
-    assert res["success"] is True
-    assert res["data"]["count"] == 1  # only db_choice has intensity 8
-
-
-def test_brain_query_all(temp_brain, sample_engrams):
-    """Test querying all engrams (no context filter)."""
-    
-    res_str = _brain_query_engrams_impl(context=None, min_intensity=1)
-    res = json.loads(res_str)
-    assert res["success"] is True
-    assert res["data"]["count"] == 3  # all engrams