refactor: reorganize services into bounded contexts and implement async database support

- Moved services to bounded context packages:
  - adaptive_learning.py → ai_analytics/adaptive_learning.py
  - analytics_service.py → ai_analytics/analytics.py
  - dynamic_pricing_engine.py → trading_marketplace/dynamic_pricing.py
  - trading_service.py → trading_marketplace/trading.py
- Implemented async database module (database_async.py):
  - Added async SQLAlchemy engine with connection pooling
  - Added

tests/test_health_checks.py

@@ -0,0 +1,218 @@
+"""
+Tests for health check utilities
+"""
+
+import pytest
+from unittest.mock import patch, Mock
+from datetime import datetime
+
+from aitbc.health_checks import (
+    HealthStatus,
+    HealthCheck,
+    HealthChecker,
+    create_basic_health_check,
+)
+
+
+class TestHealthStatus:
+    """Tests for HealthStatus enum"""
+
+    def test_health_status_values(self):
+        """Test HealthStatus enum values"""
+        assert HealthStatus.HEALTHY.value == "healthy"
+        assert HealthStatus.DEGRADED.value == "degraded"
+        assert HealthStatus.UNHEALTHY.value == "unhealthy"
+
+
+class TestHealthCheck:
+    """Tests for HealthCheck dataclass"""
+
+    def test_health_check_creation(self):
+        """Test HealthCheck dataclass creation"""
+        check = HealthCheck(
+            service="test-service",
+            status=HealthStatus.HEALTHY,
+            message="All good",
+            timestamp=datetime.now(),
+            details={"key": "value"}
+        )
+        assert check.service == "test-service"
+        assert check.status == HealthStatus.HEALTHY
+        assert check.message == "All good"
+        assert check.details == {"key": "value"}
+
+    def test_health_check_without_details(self):
+        """Test HealthCheck without optional details"""
+        check = HealthCheck(
+            service="test-service",
+            status=HealthStatus.HEALTHY,
+            message="All good",
+            timestamp=datetime.now()
+        )
+        assert check.details is None
+
+
+class TestHealthChecker:
+    """Tests for HealthChecker"""
+
+    def test_health_checker_initialization(self):
+        """Test HealthChecker initialization"""
+        checker = HealthChecker("test-service")
+        assert checker.service_name == "test-service"
+        assert checker._checks == {}
+        assert checker._last_check is None
+
+    def test_register_check(self):
+        """Test registering a health check"""
+        checker = HealthChecker("test-service")
+        
+        def mock_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        checker.register_check("memory", mock_check)
+        assert "memory" in checker._checks
+        assert checker._checks["memory"] == mock_check
+
+    @patch('aitbc.health_checks.logger')
+    def test_register_check_logs(self, mock_logger):
+        """Test register_check logs registration"""
+        checker = HealthChecker("test-service")
+        
+        def mock_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        checker.register_check("memory", mock_check)
+        mock_logger.info.assert_called_once()
+        assert "memory" in mock_logger.info.call_args[0][0]
+
+    def test_run_checks_all_healthy(self):
+        """Test run_checks when all checks pass"""
+        checker = HealthChecker("test-service")
+        
+        def mock_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        checker.register_check("check1", mock_check)
+        checker.register_check("check2", mock_check)
+        
+        result = checker.run_checks()
+        
+        assert result.service == "test-service"
+        assert result.status == HealthStatus.HEALTHY
+        assert result.message == "All health checks passed"
+        assert result.details is not None
+        assert len(result.details) == 2
+
+    def test_run_checks_one_degraded(self):
+        """Test run_checks with one degraded check"""
+        checker = HealthChecker("test-service")
+        
+        def healthy_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        def degraded_check():
+            return HealthStatus.DEGRADED, "Warning", {}
+        
+        checker.register_check("healthy", healthy_check)
+        checker.register_check("degraded", degraded_check)
+        
+        result = checker.run_checks()
+        
+        assert result.status == HealthStatus.DEGRADED
+        assert "degraded" in result.message
+
+    def test_run_checks_one_unhealthy(self):
+        """Test run_checks with one unhealthy check"""
+        checker = HealthChecker("test-service")
+        
+        def healthy_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        def unhealthy_check():
+            return HealthStatus.UNHEALTHY, "Error", {}
+        
+        checker.register_check("healthy", healthy_check)
+        checker.register_check("unhealthy", unhealthy_check)
+        
+        result = checker.run_checks()
+        
+        assert result.status == HealthStatus.UNHEALTHY
+        assert "unhealthy" in result.message
+
+    @patch('aitbc.health_checks.logger')
+    def test_run_checks_with_exception(self, mock_logger):
+        """Test run_checks handles exceptions in checks"""
+        checker = HealthChecker("test-service")
+        
+        def failing_check():
+            raise ValueError("Check failed")
+        
+        checker.register_check("failing", failing_check)
+        
+        result = checker.run_checks()
+        
+        assert result.status == HealthStatus.UNHEALTHY
+        assert "failing" in result.message
+        mock_logger.error.assert_called_once()
+
+    def test_get_last_check_before_run(self):
+        """Test get_last_check returns None before any check run"""
+        checker = HealthChecker("test-service")
+        assert checker.get_last_check() is None
+
+    def test_get_last_check_after_run(self):
+        """Test get_last_check returns last check result"""
+        checker = HealthChecker("test-service")
+        
+        def mock_check():
+            return HealthStatus.HEALTHY, "OK", {}
+        
+        checker.register_check("check1", mock_check)
+        checker.run_checks()
+        
+        last_check = checker.get_last_check()
+        assert last_check is not None
+        assert last_check.service == "test-service"
+
+    def test_get_health_dict(self):
+        """Test get_health_dict returns dictionary representation"""
+        checker = HealthChecker("test-service")
+        
+        def mock_check():
+            return HealthStatus.HEALTHY, "OK", {"key": "value"}
+        
+        checker.register_check("check1", mock_check)
+        health_dict = checker.get_health_dict()
+        
+        assert isinstance(health_dict, dict)
+        assert "service" in health_dict
+        assert "status" in health_dict
+        assert "message" in health_dict
+        assert "timestamp" in health_dict
+        assert health_dict["service"] == "test-service"
+
+
+class TestCreateBasicHealthCheck:
+    """Tests for create_basic_health_check"""
+
+    def test_create_basic_health_check(self):
+        """Test create_basic_health_check returns HealthChecker"""
+        checker = create_basic_health_check("test-service")
+        assert isinstance(checker, HealthChecker)
+        assert checker.service_name == "test-service"
+
+    def test_create_basic_health_check_without_psutil(self):
+        """Test create_basic_health_check handles psutil ImportError"""
+        # Skip this test as psutil import handling is complex to mock
+        pytest.skip("psutil import handling requires complex mocking")
+
+    def test_basic_health_check_has_checks(self):
+        """Test basic health check has registered checks when psutil available"""
+        try:
+            import psutil
+            checker = create_basic_health_check("test-service")
+            # Should have memory and disk checks if psutil is available
+            assert len(checker._checks) > 0
+        except ImportError:
+            # Skip if psutil not available
+            pass