ic-code 1.0.0__py3-none-any.whl

ic/compat/__init__.py

@@ -0,0 +1,241 @@
+"""
+Backward compatibility layer for IC package.
+
+This module provides compatibility shims for existing import paths and functionality
+to ensure smooth migration from the old structure to the new src/ layout.
+"""
+
+import warnings
+from typing import Any, Dict, Optional
+import os
+from pathlib import Path
+
+# Import new modules
+from ..config.manager import ConfigManager
+from ..config.security import SecurityManager
+from ..core.logging import ICLogger
+from ..core.session import AWSSessionManager
+from ..core.mcp_manager import MCPManager
+
+# Global compatibility instances
+_config_manager: Optional[ConfigManager] = None
+_logger: Optional[ICLogger] = None
+_aws_session_manager: Optional[AWSSessionManager] = None
+
+
+def get_config_manager() -> ConfigManager:
+    """Get or create global ConfigManager instance."""
+    global _config_manager
+    if _config_manager is None:
+        security_manager = SecurityManager()
+        _config_manager = ConfigManager(security_manager=security_manager)
+        # Load configuration with .env fallback
+        _config_manager.load_config()
+    return _config_manager
+
+
+def get_logger() -> ICLogger:
+    """Get or create global ICLogger instance."""
+    global _logger
+    if _logger is None:
+        config_manager = get_config_manager()
+        config = config_manager.get_config()
+        _logger = ICLogger(config)
+    return _logger
+
+
+def get_aws_session_manager() -> AWSSessionManager:
+    """Get or create global AWSSessionManager instance."""
+    global _aws_session_manager
+    if _aws_session_manager is None:
+        config_manager = get_config_manager()
+        config = config_manager.get_config()
+        _aws_session_manager = AWSSessionManager(config)
+    return _aws_session_manager
+
+
+def warn_deprecated(old_path: str, new_path: str, version: str = "2.0.0") -> None:
+    """Issue deprecation warning for old import paths."""
+    warnings.warn(
+        f"'{old_path}' is deprecated and will be removed in version {version}. "
+        f"Please use '{new_path}' instead.",
+        DeprecationWarning,
+        stacklevel=3
+    )
+
+
+class CompatibilityConfig:
+    """
+    Compatibility wrapper for configuration access.
+    
+    Provides backward compatibility for .env file access while encouraging
+    migration to the new YAML-based configuration system.
+    """
+    
+    def __init__(self):
+        self._config_manager = get_config_manager()
+        self._env_loaded = False
+        self._load_env_if_needed()
+    
+    def _load_env_if_needed(self):
+        """Load .env file if it exists and hasn't been loaded yet."""
+        if not self._env_loaded:
+            env_file = Path('.env')
+            if env_file.exists():
+                try:
+                    from dotenv import load_dotenv
+                    load_dotenv()
+                    self._env_loaded = True
+                    
+                    # Issue deprecation warning
+                    warn_deprecated(
+                        ".env file usage",
+                        "YAML configuration files (config.yaml)",
+                        "2.0.0"
+                    )
+                except ImportError:
+                    pass
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value with .env fallback.
+        
+        Args:
+            key: Configuration key (supports dot notation)
+            default: Default value if key not found
+            
+        Returns:
+            Configuration value
+        """
+        # Try new config system first
+        value = self._config_manager.get_config_value(key, None)
+        if value is not None:
+            return value
+        
+        # Fallback to environment variable
+        env_key = key.upper().replace('.', '_')
+        env_value = os.getenv(env_key)
+        if env_value is not None:
+            return env_value
+        
+        # Legacy environment variable mappings
+        legacy_mappings = {
+            'aws.accounts': 'AWS_ACCOUNTS',
+            'aws.regions': 'AWS_REGIONS',
+            'aws.cross_account_role': 'AWS_CROSS_ACCOUNT_ROLE',
+            'azure.subscription_id': 'AZURE_SUBSCRIPTION_ID',
+            'azure.tenant_id': 'AZURE_TENANT_ID',
+            'azure.client_id': 'AZURE_CLIENT_ID',
+            'azure.client_secret': 'AZURE_CLIENT_SECRET',
+            'gcp.project_id': 'GCP_PROJECT_ID',
+            'gcp.service_account_key_path': 'GCP_SERVICE_ACCOUNT_KEY_PATH',
+            'cloudflare.email': 'CLOUDFLARE_EMAIL',
+            'cloudflare.api_token': 'CLOUDFLARE_API_TOKEN',
+            'slack.webhook_url': 'SLACK_WEBHOOK_URL',
+        }
+        
+        legacy_env_key = legacy_mappings.get(key)
+        if legacy_env_key:
+            legacy_value = os.getenv(legacy_env_key)
+            if legacy_value is not None:
+                return legacy_value
+        
+        return default
+    
+    def get_all(self) -> Dict[str, Any]:
+        """Get all configuration as dictionary."""
+        return self._config_manager.get_config()
+    
+    def reload(self) -> None:
+        """Reload configuration from all sources."""
+        self._config_manager.load_config()
+        self._env_loaded = False
+        self._load_env_if_needed()
+
+
+# Global compatibility config instance
+compat_config = CompatibilityConfig()
+
+
+def get_env_value(key: str, default: Any = None) -> Any:
+    """
+    Backward compatibility function for environment variable access.
+    
+    Args:
+        key: Environment variable key
+        default: Default value if not found
+        
+    Returns:
+        Environment variable value or default
+    """
+    warn_deprecated(
+        f"get_env_value('{key}')",
+        f"compat_config.get('{key.lower().replace('_', '.')}')",
+        "2.0.0"
+    )
+    return os.getenv(key, default)
+
+
+def load_dotenv_compat():
+    """
+    Backward compatibility function for loading .env files.
+    """
+    warn_deprecated(
+        "load_dotenv_compat()",
+        "ConfigManager.load_config() with YAML files",
+        "2.0.0"
+    )
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+    except ImportError:
+        pass
+
+
+# Compatibility aliases for common functions
+def get_aws_accounts() -> list:
+    """Get AWS accounts from configuration."""
+    accounts = compat_config.get('aws.accounts', [])
+    if isinstance(accounts, str):
+        return [acc.strip() for acc in accounts.split(',') if acc.strip()]
+    return accounts or []
+
+
+def get_aws_regions() -> list:
+    """Get AWS regions from configuration."""
+    regions = compat_config.get('aws.regions', ['ap-northeast-2'])
+    if isinstance(regions, str):
+        return [reg.strip() for reg in regions.split(',') if reg.strip()]
+    return regions
+
+
+def get_azure_subscription_id() -> Optional[str]:
+    """Get Azure subscription ID from configuration."""
+    return compat_config.get('azure.subscription_id')
+
+
+def get_gcp_project_id() -> Optional[str]:
+    """Get GCP project ID from configuration."""
+    return compat_config.get('gcp.project_id')
+
+
+def get_slack_webhook_url() -> Optional[str]:
+    """Get Slack webhook URL from configuration."""
+    return compat_config.get('slack.webhook_url')
+
+
+# Export compatibility functions
+__all__ = [
+    'get_config_manager',
+    'get_logger', 
+    'get_aws_session_manager',
+    'compat_config',
+    'get_env_value',
+    'load_dotenv_compat',
+    'get_aws_accounts',
+    'get_aws_regions',
+    'get_azure_subscription_id',
+    'get_gcp_project_id',
+    'get_slack_webhook_url',
+    'warn_deprecated',
+]

ic/compat/cli.py

@@ -0,0 +1,289 @@
+"""
+Backward compatibility layer for CLI functionality.
+
+This module ensures that existing CLI commands continue to work while
+providing migration path to new configuration system.
+"""
+
+import os
+import sys
+import warnings
+from typing import Any, Dict, Optional
+from pathlib import Path
+
+# Import compatibility layer
+from . import warn_deprecated, compat_config, get_logger
+
+
+def ensure_env_compatibility():
+    """
+    Ensure environment variable compatibility for CLI commands.
+    
+    This function checks for .env files and loads them if the new
+    configuration system hasn't been set up yet.
+    """
+    # Check if new config exists
+    config_paths = [
+        Path("ic.yaml"),
+        Path(".ic/config.yaml"), 
+        Path("config/config.yaml"),
+        Path.home() / ".ic" / "config.yaml",
+    ]
+    
+    has_new_config = any(path.exists() for path in config_paths)
+    
+    # If no new config exists, ensure .env is loaded
+    if not has_new_config:
+        env_file = Path('.env')
+        if env_file.exists():
+            try:
+                from dotenv import load_dotenv
+                load_dotenv()
+                
+                # Issue one-time warning about migration
+                if not os.getenv('IC_MIGRATION_WARNING_SHOWN'):
+                    logger = get_logger()
+                    logger.log_info_file_only(
+                        "Using .env file for configuration. "
+                        "Consider migrating to YAML configuration with 'ic config migrate'"
+                    )
+                    os.environ['IC_MIGRATION_WARNING_SHOWN'] = '1'
+                    
+            except ImportError:
+                warnings.warn(
+                    "python-dotenv not installed. .env file cannot be loaded. "
+                    "Install with: pip install python-dotenv",
+                    ImportWarning
+                )
+
+
+def wrap_command_function(original_func):
+    """
+    Decorator to wrap existing command functions with compatibility layer.
+    
+    Args:
+        original_func: Original command function
+        
+    Returns:
+        Wrapped function with compatibility features
+    """
+    def wrapper(args):
+        # Ensure environment compatibility
+        ensure_env_compatibility()
+        
+        # Add compatibility attributes to args if needed
+        if not hasattr(args, '_ic_compat_wrapped'):
+            args._ic_compat_wrapped = True
+            
+            # Add configuration access to args
+            args.config = compat_config
+            
+            # Add logger access to args
+            args.logger = get_logger()
+        
+        # Call original function
+        return original_func(args)
+    
+    return wrapper
+
+
+def get_legacy_env_vars() -> Dict[str, str]:
+    """
+    Get legacy environment variables that might be needed for compatibility.
+    
+    Returns:
+        Dictionary of legacy environment variables
+    """
+    legacy_vars = {}
+    
+    # AWS legacy variables
+    aws_vars = [
+        'AWS_PROFILE', 'AWS_REGION', 'AWS_ACCESS_KEY_ID', 'AWS_SECRET_ACCESS_KEY',
+        'AWS_SESSION_TOKEN', 'AWS_ACCOUNTS', 'AWS_REGIONS', 'AWS_CROSS_ACCOUNT_ROLE'
+    ]
+    
+    # Azure legacy variables
+    azure_vars = [
+        'AZURE_SUBSCRIPTION_ID', 'AZURE_TENANT_ID', 'AZURE_CLIENT_ID', 
+        'AZURE_CLIENT_SECRET', 'AZURE_SUBSCRIPTIONS', 'AZURE_LOCATIONS'
+    ]
+    
+    # GCP legacy variables
+    gcp_vars = [
+        'GCP_PROJECT_ID', 'GCP_PROJECTS', 'GCP_REGIONS', 'GCP_ZONES',
+        'GCP_SERVICE_ACCOUNT_KEY_PATH', 'GOOGLE_APPLICATION_CREDENTIALS'
+    ]
+    
+    # CloudFlare legacy variables
+    cf_vars = [
+        'CLOUDFLARE_EMAIL', 'CLOUDFLARE_API_TOKEN', 'CLOUDFLARE_ACCOUNTS', 'CLOUDFLARE_ZONES'
+    ]
+    
+    # Other legacy variables
+    other_vars = [
+        'SLACK_WEBHOOK_URL', 'SSH_CONFIG_FILE', 'SSH_KEY_DIR', 'OCI_CONFIG_PATH'
+    ]
+    
+    all_vars = aws_vars + azure_vars + gcp_vars + cf_vars + other_vars
+    
+    for var in all_vars:
+        value = os.getenv(var)
+        if value:
+            legacy_vars[var] = value
+    
+    return legacy_vars
+
+
+def migrate_env_to_config_hint():
+    """
+    Provide hint about migrating from .env to config files.
+    """
+    env_file = Path('.env')
+    if env_file.exists():
+        config_paths = [
+            Path("ic.yaml"),
+            Path(".ic/config.yaml"),
+            Path("config/config.yaml"),
+        ]
+        
+        has_config = any(path.exists() for path in config_paths)
+        
+        if not has_config:
+            logger = get_logger()
+            logger.log_info_file_only(
+                "💡 Tip: Migrate from .env to YAML configuration for better security and features. "
+                "Run 'ic config migrate' to get started."
+            )
+
+
+def check_deprecated_imports():
+    """
+    Check for deprecated import patterns in the current execution.
+    """
+    # This is called during CLI startup to check for deprecated usage
+    frame = sys._getframe(1)
+    
+    # Check if we're being imported from old paths
+    if frame and frame.f_code:
+        filename = frame.f_code.co_filename
+        if 'common/log.py' in filename or 'common/gather_env.py' in filename:
+            warn_deprecated(
+                "importing from common.* modules",
+                "importing from ic.compat or using new configuration system",
+                "2.0.0"
+            )
+
+
+def setup_cli_compatibility():
+    """
+    Set up CLI compatibility features.
+    
+    This function should be called early in CLI initialization to ensure
+    backward compatibility features are available.
+    """
+    # Ensure environment compatibility
+    ensure_env_compatibility()
+    
+    # Check for deprecated imports
+    check_deprecated_imports()
+    
+    # Provide migration hints
+    migrate_env_to_config_hint()
+    
+    # Set up global compatibility state
+    if not hasattr(sys.modules[__name__], '_cli_compat_initialized'):
+        sys.modules[__name__]._cli_compat_initialized = True
+        
+        # Log compatibility mode activation
+        logger = get_logger()
+        logger.log_info_file_only("CLI compatibility layer activated")
+
+
+def get_command_config(command_name: str) -> Dict[str, Any]:
+    """
+    Get configuration for a specific command with backward compatibility.
+    
+    Args:
+        command_name: Name of the command
+        
+    Returns:
+        Configuration dictionary for the command
+    """
+    # Get base configuration
+    config = compat_config.get_all()
+    
+    # Add command-specific compatibility mappings
+    if command_name.startswith('aws'):
+        # Ensure AWS configuration is available
+        if not config.get('aws', {}).get('accounts'):
+            accounts_env = os.getenv('AWS_ACCOUNTS')
+            if accounts_env:
+                if 'aws' not in config:
+                    config['aws'] = {}
+                config['aws']['accounts'] = [acc.strip() for acc in accounts_env.split(',')]
+    
+    elif command_name.startswith('azure'):
+        # Ensure Azure configuration is available
+        if not config.get('azure', {}).get('subscription_id'):
+            sub_id = os.getenv('AZURE_SUBSCRIPTION_ID')
+            if sub_id:
+                if 'azure' not in config:
+                    config['azure'] = {}
+                config['azure']['subscription_id'] = sub_id
+    
+    elif command_name.startswith('gcp'):
+        # Ensure GCP configuration is available
+        if not config.get('gcp', {}).get('project_id'):
+            project_id = os.getenv('GCP_PROJECT_ID')
+            if project_id:
+                if 'gcp' not in config:
+                    config['gcp'] = {}
+                config['gcp']['project_id'] = project_id
+    
+    return config
+
+
+def handle_missing_config(service: str) -> None:
+    """
+    Handle missing configuration for a service with helpful error messages.
+    
+    Args:
+        service: Name of the service (aws, azure, gcp, etc.)
+    """
+    logger = get_logger()
+    
+    error_messages = {
+        'aws': (
+            "AWS configuration not found. Please either:\n"
+            "1. Create a YAML config file with AWS settings, or\n"
+            "2. Set AWS_ACCOUNTS environment variable, or\n"
+            "3. Run 'ic config init' to set up configuration"
+        ),
+        'azure': (
+            "Azure configuration not found. Please either:\n"
+            "1. Create a YAML config file with Azure settings, or\n"
+            "2. Set AZURE_SUBSCRIPTION_ID environment variable, or\n"
+            "3. Run 'ic config init' to set up configuration"
+        ),
+        'gcp': (
+            "GCP configuration not found. Please either:\n"
+            "1. Create a YAML config file with GCP settings, or\n"
+            "2. Set GCP_PROJECT_ID environment variable, or\n"
+            "3. Run 'ic config init' to set up configuration"
+        ),
+    }
+    
+    message = error_messages.get(service, f"{service} configuration not found")
+    logger.log_error(message)
+
+
+# Export compatibility functions
+__all__ = [
+    'ensure_env_compatibility',
+    'wrap_command_function',
+    'get_legacy_env_vars',
+    'migrate_env_to_config_hint',
+    'setup_cli_compatibility',
+    'get_command_config',
+    'handle_missing_config',
+]