coding_tool_factory.py

"""
Factory classes for creating OS-specific detectors.

This module provides factory classes that create appropriate detector instances
based on the operating system.
"""

import platform
from typing import Optional

# Base classes
from .coding_tool_base import (
    BaseDeviceIdExtractor,
    BaseToolDetector,
    BaseCursorRulesExtractor,
    BaseClaudeRulesExtractor,
    BaseWindsurfRulesExtractor,
    BaseClineRulesExtractor,
    BaseRooRulesExtractor,
    BaseAntigravityRulesExtractor,
    BaseKiloCodeRulesExtractor,
    BaseGeminiCliRulesExtractor,
    BaseCodexRulesExtractor,
    BaseOpenCodeRulesExtractor,
    BaseCursorCliRulesExtractor,
    BaseCopilotCliRulesExtractor,
    BaseCopilotCliSettingsExtractor,
    BaseCopilotCliSkillsExtractor,
    BaseMCPConfigExtractor,
    BaseClaudeSettingsExtractor,
    BaseCursorSettingsExtractor,
    BaseOpenClawDetector,
    BaseCopilotDetector,
    BaseJunieRulesExtractor,
    BaseClaudeSkillsExtractor,
    BaseClaudeCoworkSkillsExtractor,
    BaseCursorSkillsExtractor,
    BaseClineSkillsExtractor,
)

# macOS - Shared
from .macos import MacOSDeviceIdExtractor, MacOSCursorDetector, MacOSClaudeDetector
from .macos import MacOSClaudeCoworkDetector, MacOSClaudeCoworkSkillsExtractor

# macOS - Cursor
from .macos.cursor.cursor_rules_extractor import MacOSCursorRulesExtractor
from .macos.cursor.mcp_config_extractor import MacOSCursorMCPConfigExtractor
from .macos.cursor.settings_extractor import MacOSCursorSettingsExtractor

# macOS - Claude Code
from .macos.claude_code.claude_rules_extractor import MacOSClaudeRulesExtractor
from .macos.claude_code.mcp_config_extractor import MacOSClaudeMCPConfigExtractor
from .macos.claude_code.settings_extractor import MacOSClaudeSettingsExtractor
from .macos.claude_code.skills_extractor import MacOSClaudeSkillsExtractor
from .macos.cursor.skills_extractor import MacOSCursorSkillsExtractor

# macOS - Windsurf
from .macos.windsurf.windsurf import MacOSWindsurfDetector
from .macos.windsurf.windsurf_rules_extractor import MacOSWindsurfRulesExtractor
from .macos.windsurf.mcp_config_extractor import MacOSWindsurfMCPConfigExtractor

# macOS - Roo Code
from .macos.roo_code.roo_code import MacOSRooDetector
from .macos.roo_code.mcp_config_extractor import MacOSRooMCPConfigExtractor
from .macos.roo_code.roo_code_rules_extractor import MacOSRooRulesExtractor

# Windows - Roo Code
from .windows.roo_code.roo_code import WindowsRooDetector
from .windows.roo_code.mcp_config_extractor import WindowsRooMCPConfigExtractor
from .windows.roo_code.roo_code_rules_extractor import WindowsRooRulesExtractor

# macOS - Cline
from .macos.cline.cline import MacOSClineDetector
from .macos.cline.cline_rules_extractor import MacOSClineRulesExtractor
from .macos.cline.mcp_config_extractor import MacOSClineMCPConfigExtractor
from .macos.cline.skills_extractor import MacOSClineSkillsExtractor

# macOS - Antigravity
from .macos.antigravity.antigravity import MacOSAntigravityDetector
from .macos.antigravity.antigravity_rules_extractor import MacOSAntigravityRulesExtractor
from .macos.antigravity.mcp_config_extractor import MacOSAntigravityMCPConfigExtractor

# macOS - Kilo Code
from .macos.kilocode.kilocode import MacOSKiloCodeDetector
from .macos.kilocode.kilocode_rules_extractor import MacOSKiloCodeRulesExtractor
from .macos.kilocode.mcp_config_extractor import MacOSKiloCodeMCPConfigExtractor

# macOS - Gemini CLI
from .macos.gemini_cli.gemini_cli import MacOSGeminiCliDetector
from .macos.gemini_cli.gemini_cli_rules_extractor import MacOSGeminiCliRulesExtractor
from .macos.gemini_cli.mcp_config_extractor import MacOSGeminiCliMCPConfigExtractor

# macOS - Cursor CLI
from .macos.cursor_cli.cursor_cli import MacOSCursorCliDetector
from .macos.cursor_cli.cursor_cli_rules_extractor import MacOSCursorCliRulesExtractor
from .macos.cursor_cli.settings_extractor import MacOSCursorCliSettingsExtractor
from .macos.cursor_cli.mcp_config_extractor import MacOSCursorCliMCPConfigExtractor

# macOS - Codex
from .macos.codex.codex import MacOSCodexDetector
from .macos.codex.codex_rules_extractor import MacOSCodexRulesExtractor
from .macos.codex.mcp_config_extractor import MacOSCodexMCPConfigExtractor

# macOS - Replit
from .macos.replit.replit import MacOSReplitDetector

# macOS - OpenClaw
from .macos.openclaw.detect_openclaw import MacOSOpenClawDetector

# Windows - OpenClaw
from .windows.openclaw.detect_openclaw import WindowsOpenClawDetector

# macOS - Copilot
from .macos.github_copilot.detect_copilot import MacOSCopilotDetector
from .macos.github_copilot.mcp_config_extractor import MacOSGitHubCopilotMCPConfigExtractor
from .macos.github_copilot.copilot_rules_extractor import MacOSGitHubCopilotRulesExtractor

# macOS - Copilot CLI (standalone @github/copilot agentic terminal tool)
from .macos.copilot_cli.copilot_cli import MacOSCopilotCliDetector
from .macos.copilot_cli.mcp_config_extractor import MacOSCopilotCliMCPConfigExtractor
from .macos.copilot_cli.copilot_cli_rules_extractor import MacOSCopilotCliRulesExtractor
from .macos.copilot_cli.copilot_cli_settings_extractor import MacOSCopilotCliSettingsExtractor
from .macos.copilot_cli.copilot_cli_skills_extractor import MacOSCopilotCliSkillsExtractor

# Windows - Copilot
from .windows.github_copilot.detect_copilot import WindowsGitHubCopilotDetector
from .windows.github_copilot.mcp_config_extractor import WindowsGitHubCopilotMCPConfigExtractor
from .windows.github_copilot.copilot_rules_extractor import WindowsGitHubCopilotRulesExtractor

# Windows - Copilot CLI (standalone @github/copilot agentic terminal tool)
from .windows.copilot_cli.copilot_cli import WindowsCopilotCliDetector
from .windows.copilot_cli.mcp_config_extractor import WindowsCopilotCliMCPConfigExtractor
from .windows.copilot_cli.copilot_cli_rules_extractor import WindowsCopilotCliRulesExtractor
from .windows.copilot_cli.copilot_cli_settings_extractor import WindowsCopilotCliSettingsExtractor
from .windows.copilot_cli.copilot_cli_skills_extractor import WindowsCopilotCliSkillsExtractor

# Windows - Replit
from .windows.replit.replit import WindowsReplitDetector
# Windows - Codex
from .windows.codex.codex import WindowsCodexDetector
from .windows.codex.codex_rules_extractor import WindowsCodexRulesExtractor
from .windows.codex.mcp_config_extractor import WindowsCodexMCPConfigExtractor

# macOS - OpenCode
from .macos.opencode.opencode import MacOSOpenCodeDetector
from .macos.opencode.opencode_rules_extractor import MacOSOpenCodeRulesExtractor
from .macos.opencode.mcp_config_extractor import MacOSOpenCodeMCPConfigExtractor

# macOS - JetBrains
from .macos.jetbrains.jetbrains import MacOSJetBrainsDetector
from .macos.jetbrains.mcp_config_extractor import MacOSJetBrainsMCPConfigExtractor

# macOS - Junie
from .macos.junie.junie import MacOSJunieDetector
from .macos.junie.mcp_config_extractor import MacOSJunieMCPConfigExtractor
from .macos.junie.junie_rules_extractor import MacOSJunieRulesExtractor

# Windows - Junie
from .windows.junie.junie import WindowsJunieDetector
from .windows.junie.mcp_config_extractor import WindowsJunieMCPConfigExtractor
from .windows.junie.junie_rules_extractor import WindowsJunieRulesExtractor

# Windows - JetBrains
from .windows.jetbrains.jetbrains import WindowsJetBrainsDetector
from .windows.jetbrains.mcp_config_extractor import WindowsJetBrainsMCPConfigExtractor

# Windows - OpenCode
from .windows.opencode.opencode import WindowsOpenCodeDetector
from .windows.opencode.opencode_rules_extractor import WindowsOpenCodeRulesExtractor
from .windows.opencode.mcp_config_extractor import WindowsOpenCodeMCPConfigExtractor

# Windows - Gemini CLI
from .windows.gemini_cli.gemini_cli import WindowsGeminiCliDetector
from .windows.gemini_cli.gemini_cli_rules_extractor import WindowsGeminiCliRulesExtractor
from .windows.gemini_cli.mcp_config_extractor import WindowsGeminiCliMCPConfigExtractor

# Windows - Cursor CLI
from .windows.cursor_cli.cursor_cli import WindowsCursorCliDetector
from .windows.cursor_cli.cursor_cli_rules_extractor import WindowsCursorCliRulesExtractor
from .windows.cursor_cli.settings_extractor import WindowsCursorCliSettingsExtractor
from .windows.cursor_cli.mcp_config_extractor import WindowsCursorCliMCPConfigExtractor

# Windows - Shared
from .windows import WindowsDeviceIdExtractor, WindowsCursorDetector, WindowsClaudeDetector
from .windows import WindowsClaudeCoworkDetector, WindowsClaudeCoworkSkillsExtractor

# Linux - Shared
from .linux import (
    LinuxDeviceIdExtractor,
    LinuxClaudeDetector,
    LinuxClaudeSettingsExtractor,
    LinuxClaudeSkillsExtractor,
    LinuxCursorDetector,
    LinuxCursorSettingsExtractor,
    LinuxCursorSkillsExtractor,
    LinuxWindsurfDetector,
    LinuxRooDetector,
    LinuxRooRulesExtractor,
    LinuxRooMCPConfigExtractor,
    LinuxClineDetector,
    LinuxClineRulesExtractor,
    LinuxClineMCPConfigExtractor,
    LinuxClineSkillsExtractor,
    LinuxAntigravityDetector,
    LinuxAntigravityRulesExtractor,
    LinuxAntigravityMCPConfigExtractor,
    LinuxKiloCodeDetector,
    LinuxKiloCodeRulesExtractor,
    LinuxKiloCodeMCPConfigExtractor,
    LinuxGeminiCliDetector,
    LinuxGeminiCliRulesExtractor,
    LinuxGeminiCliMCPConfigExtractor,
    LinuxCursorCliDetector,
    LinuxCursorCliRulesExtractor,
    LinuxCursorCliMCPConfigExtractor,
    LinuxCursorCliSettingsExtractor,
    LinuxCopilotCliDetector,
    LinuxCopilotCliMCPConfigExtractor,
    LinuxCopilotCliRulesExtractor,
    LinuxCopilotCliSettingsExtractor,
    LinuxCopilotCliSkillsExtractor,
    LinuxCodexDetector,
    LinuxCodexRulesExtractor,
    LinuxCodexMCPConfigExtractor,
    LinuxOpenCodeDetector,
    LinuxOpenCodeRulesExtractor,
    LinuxOpenCodeMCPConfigExtractor,
    LinuxOpenClawDetector,
    LinuxReplitDetector,
    LinuxJetBrainsDetector,
    LinuxJetBrainsMCPConfigExtractor,
    LinuxCopilotDetector,
    LinuxGitHubCopilotRulesExtractor,
    LinuxGitHubCopilotMCPConfigExtractor,
    LinuxClaudeCoworkDetector,
    LinuxClaudeCoworkSkillsExtractor,
    LinuxJunieDetector,
    LinuxJunieRulesExtractor,
    LinuxJunieMCPConfigExtractor,
)

# Linux - Claude Code
from .linux.claude_code.claude_rules_extractor import LinuxClaudeRulesExtractor
from .linux.claude_code.mcp_config_extractor import LinuxClaudeMCPConfigExtractor

# Linux - Cursor
from .linux.cursor.cursor_rules_extractor import LinuxCursorRulesExtractor
from .linux.cursor.mcp_config_extractor import LinuxCursorMCPConfigExtractor

# Linux - Windsurf
from .linux.windsurf.windsurf_rules_extractor import LinuxWindsurfRulesExtractor
from .linux.windsurf.mcp_config_extractor import LinuxWindsurfMCPConfigExtractor

# Windows - Cursor
from .windows.cursor.cursor_rules_extractor import WindowsCursorRulesExtractor
from .windows.cursor.mcp_config_extractor import WindowsCursorMCPConfigExtractor
from .windows.cursor.settings_extractor import WindowsCursorSettingsExtractor

# Windows - Claude Code
from .windows.claude_code.claude_rules_extractor import WindowsClaudeRulesExtractor
from .windows.claude_code.mcp_config_extractor import WindowsClaudeMCPConfigExtractor
from .windows.claude_code.settings_extractor import WindowsClaudeSettingsExtractor
from .windows.claude_code.skills_extractor import WindowsClaudeSkillsExtractor
from .windows.cursor.skills_extractor import WindowsCursorSkillsExtractor

# Windows - Windsurf
from .windows.windsurf.windsurf import WindowsWindsurfDetector
from .windows.windsurf.windsurf_rules_extractor import WindowsWindsurfRulesExtractor
from .windows.windsurf.mcp_config_extractor import WindowsWindsurfMCPConfigExtractor

# Windows - Antigravity
from .windows.antigravity.antigravity import WindowsAntigravityDetector
from .windows.antigravity.antigravity_rules_extractor import WindowsAntigravityRulesExtractor
from .windows.antigravity.mcp_config_extractor import WindowsAntigravityMCPConfigExtractor

# Windows - Cline
from .windows.cline.cline import WindowsClineDetector
from .windows.cline.cline_rules_extractor import WindowsClineRulesExtractor
from .windows.cline.mcp_config_extractor import WindowsClineMCPConfigExtractor
from .windows.cline.skills_extractor import WindowsClineSkillsExtractor

# Windows - Kilo Code
from .windows.kilocode.kilocode import WindowsKiloCodeDetector
from .windows.kilocode.kilocode_rules_extractor import WindowsKiloCodeRulesExtractor
from .windows.kilocode.mcp_config_extractor import WindowsKiloCodeMCPConfigExtractor


class DeviceIdExtractorFactory:
    """Factory for creating OS-specific device ID extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseDeviceIdExtractor:
        """
        Create appropriate device ID extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseDeviceIdExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSDeviceIdExtractor()
        elif os_name == "Windows":
            return WindowsDeviceIdExtractor()
        elif os_name == "Linux":
            return LinuxDeviceIdExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class ToolDetectorFactory:
    """Factory for creating OS-specific tool detectors."""

    @staticmethod
    def create_cursor_detector(os_name: Optional[str] = None) -> BaseToolDetector:
        """
        Create appropriate Cursor detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorDetector()
        elif os_name == "Windows":
            return WindowsCursorDetector()
        elif os_name == "Linux":
            return LinuxCursorDetector()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")

    @staticmethod
    def create_claude_detector(os_name: Optional[str] = None) -> BaseToolDetector:
        """
        Create appropriate Claude Code detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeDetector()
        elif os_name == "Windows":
            return WindowsClaudeDetector()
        elif os_name == "Linux":
            return LinuxClaudeDetector()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")

    @staticmethod
    def create_claude_cowork_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Claude Cowork detector for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeCoworkDetector()
        elif os_name == "Windows":
            return WindowsClaudeCoworkDetector()
        elif os_name == "Linux":
            return LinuxClaudeCoworkDetector()
        else:
            return None

    @staticmethod
    def create_windsurf_detector(os_name: Optional[str] = None) -> BaseToolDetector:
        """
        Create appropriate Windsurf detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSWindsurfDetector()
        elif os_name == "Windows":
            return WindowsWindsurfDetector()
        elif os_name == "Linux":
            return LinuxWindsurfDetector()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")

    @staticmethod
    def create_roo_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Roo Code detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSRooDetector()
        elif os_name == "Windows":
            return WindowsRooDetector()
        elif os_name == "Linux":
            return LinuxRooDetector()
        else:
            return None

    @staticmethod
    def create_cline_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Cline detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClineDetector()
        elif os_name == "Windows":
            return WindowsClineDetector()
        elif os_name == "Linux":
            return LinuxClineDetector()
        else:
            return None

    @staticmethod
    def create_antigravity_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Antigravity detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSAntigravityDetector()
        elif os_name == "Windows":
            return WindowsAntigravityDetector()
        elif os_name == "Linux":
            return LinuxAntigravityDetector()
        else:
            return None

    @staticmethod
    def create_kilocode_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Kilo Code detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSKiloCodeDetector()
        elif os_name == "Windows":
            return WindowsKiloCodeDetector()
        elif os_name == "Linux":
            return LinuxKiloCodeDetector()
        else:
            return None

    @staticmethod
    def create_gemini_cli_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Gemini CLI detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSGeminiCliDetector()
        elif os_name == "Windows":
            return WindowsGeminiCliDetector()
        elif os_name == "Linux":
            return LinuxGeminiCliDetector()
        else:
            return None

    @staticmethod
    def create_cursor_cli_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Cursor CLI detector for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorCliDetector()
        elif os_name == "Windows":
            return WindowsCursorCliDetector()
        elif os_name == "Linux":
            return LinuxCursorCliDetector()
        else:
            return None

    @staticmethod
    def create_codex_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Codex detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCodexDetector()
        elif os_name == "Windows":
            return WindowsCodexDetector()
        elif os_name == "Linux":
            return LinuxCodexDetector()
        else:
            return None

    @staticmethod
    def create_replit_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Replit detector for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSReplitDetector()
        elif os_name == "Windows":
            return WindowsReplitDetector()
        elif os_name == "Linux":
            return LinuxReplitDetector()
        else:
            return None

    @staticmethod
    def create_opencode_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate OpenCode detector for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSOpenCodeDetector()
        elif os_name == "Windows":
            return WindowsOpenCodeDetector()
        elif os_name == "Linux":
            return LinuxOpenCodeDetector()
        else:
            return None

    @staticmethod
    def create_openclaw_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate OpenClaw detector for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSOpenClawDetector()
        elif os_name == "Windows":
            return WindowsOpenClawDetector()
        elif os_name == "Linux":
            return LinuxOpenClawDetector()
        else:
            return None

    @staticmethod
    def create_copilot_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate Copilot detector for the OS.
        """
        if os_name is None:
            os_name = platform.system()
        if os_name == "Darwin":
            return MacOSCopilotDetector()
        elif os_name == "Windows":
            return WindowsGitHubCopilotDetector()
        elif os_name == "Linux":
            return LinuxCopilotDetector()
        else:
            return None

    @staticmethod
    def create_copilot_cli_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate GitHub Copilot CLI detector for the OS.
        """
        if os_name is None:
            os_name = platform.system()
        if os_name == "Darwin":
            return MacOSCopilotCliDetector()
        elif os_name == "Windows":
            return WindowsCopilotCliDetector()
        elif os_name == "Linux":
            return LinuxCopilotCliDetector()
        else:
            return None

    @staticmethod
    def create_jetbrains_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Create appropriate JetBrains IDEs detector for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseToolDetector instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSJetBrainsDetector()
        elif os_name == "Windows":
            return WindowsJetBrainsDetector()
        elif os_name == "Linux":
            return LinuxJetBrainsDetector()
        else:
            return None

    @staticmethod
    def create_junie_detector(os_name: Optional[str] = None) -> Optional[BaseToolDetector]:
        """
        Junie detector for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSJunieDetector()
        elif os_name == "Linux":
            return LinuxJunieDetector()
        elif os_name == "Windows":
            return WindowsJunieDetector()
        else:
            return None

    @staticmethod
    def create_all_tool_detectors(os_name: Optional[str] = None) -> list:
        """
        Create all supported tool detectors for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            List of BaseToolDetector instances (None values are filtered out)
        """
        if os_name is None:
            os_name = platform.system()

        detectors = [
            ToolDetectorFactory.create_cursor_detector(os_name),
            ToolDetectorFactory.create_claude_detector(os_name),
            ToolDetectorFactory.create_windsurf_detector(os_name),
            ToolDetectorFactory.create_roo_detector(os_name),
        ]

        # Add Claude Cowork detector for macOS, Windows, and Linux
        claude_cowork_detector = ToolDetectorFactory.create_claude_cowork_detector(os_name)
        if claude_cowork_detector is not None:
            detectors.append(claude_cowork_detector)
        
        # Add Cline detector for macOS and Windows
        cline_detector = ToolDetectorFactory.create_cline_detector(os_name)
        if cline_detector is not None:
            detectors.append(cline_detector)
        
        # Add Antigravity detector for both macOS and Windows
        antigravity_detector = ToolDetectorFactory.create_antigravity_detector(os_name)
        if antigravity_detector is not None:
            detectors.append(antigravity_detector)
        
        # Add Kilo Code detector for macOS and Windows
        kilocode_detector = ToolDetectorFactory.create_kilocode_detector(os_name)
        if kilocode_detector is not None:
            detectors.append(kilocode_detector)
        
        # Add Gemini CLI detector for macOS and Windows
        gemini_cli_detector = ToolDetectorFactory.create_gemini_cli_detector(os_name)
        if gemini_cli_detector is not None:
            detectors.append(gemini_cli_detector)

        # Add Cursor CLI detector for macOS and Windows
        cursor_cli_detector = ToolDetectorFactory.create_cursor_cli_detector(os_name)
        if cursor_cli_detector is not None:
            detectors.append(cursor_cli_detector)

        # Add Codex detector for macOS
        codex_detector = ToolDetectorFactory.create_codex_detector(os_name)
        if codex_detector is not None:
            detectors.append(codex_detector)
        
        # Add Replit detector for macOS
        replit_detector = ToolDetectorFactory.create_replit_detector(os_name)
        if replit_detector is not None:
            detectors.append(replit_detector)
        # Add OpenCode detector for macOS
        opencode_detector = ToolDetectorFactory.create_opencode_detector(os_name)
        if opencode_detector is not None:
            detectors.append(opencode_detector)

        openclaw_detector = ToolDetectorFactory.create_openclaw_detector(os_name)
        if openclaw_detector is not None:
            detectors.append(openclaw_detector)

        copilot_detector = ToolDetectorFactory.create_copilot_detector(os_name)
        if copilot_detector is not None:
            detectors.append(copilot_detector)

        # Add GitHub Copilot CLI detector (macOS + Windows)
        copilot_cli_detector = ToolDetectorFactory.create_copilot_cli_detector(os_name)
        if copilot_cli_detector is not None:
            detectors.append(copilot_cli_detector)

        # Add JetBrains detector for macOS
        jetbrains_detector = ToolDetectorFactory.create_jetbrains_detector(os_name)
        if jetbrains_detector is not None:
            detectors.append(jetbrains_detector)

        junie_detector = ToolDetectorFactory.create_junie_detector(os_name)
        if junie_detector is not None:
            detectors.append(junie_detector)

        # Filter out None values
        return [detector for detector in detectors if detector is not None]


class CursorRulesExtractorFactory:
    """Factory for creating OS-specific cursor rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseCursorRulesExtractor:
        """
        Create appropriate cursor rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseCursorRulesExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorRulesExtractor()
        elif os_name == "Windows":
            return WindowsCursorRulesExtractor()
        elif os_name == "Linux":
            return LinuxCursorRulesExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class ClaudeRulesExtractorFactory:
    """Factory for creating OS-specific Claude Code rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseClaudeRulesExtractor:
        """
        Create appropriate Claude Code rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseClaudeRulesExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeRulesExtractor()
        elif os_name == "Windows":
            return WindowsClaudeRulesExtractor()
        elif os_name == "Linux":
            return LinuxClaudeRulesExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class CursorMCPConfigExtractorFactory:
    """Factory for creating OS-specific Cursor MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseMCPConfigExtractor:
        """
        Create appropriate Cursor MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsCursorMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxCursorMCPConfigExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class ClaudeMCPConfigExtractorFactory:
    """Factory for creating OS-specific Claude Code MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseMCPConfigExtractor:
        """
        Create appropriate Claude Code MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsClaudeMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxClaudeMCPConfigExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class ClaudeSettingsExtractorFactory:
    """Factory for creating OS-specific Claude Code settings extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseClaudeSettingsExtractor:
        """
        Create appropriate Claude Code settings extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseClaudeSettingsExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeSettingsExtractor()
        elif os_name == "Windows":
            return WindowsClaudeSettingsExtractor()
        elif os_name == "Linux":
            return LinuxClaudeSettingsExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class CursorSettingsExtractorFactory:
    """Factory for creating OS-specific Cursor IDE settings extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseCursorSettingsExtractor:
        """
        Create appropriate Cursor IDE settings extractor for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorSettingsExtractor()
        elif os_name == "Windows":
            return WindowsCursorSettingsExtractor()
        elif os_name == "Linux":
            return LinuxCursorSettingsExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class WindsurfRulesExtractorFactory:
    """Factory for creating OS-specific Windsurf rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseWindsurfRulesExtractor:
        """
        Create appropriate Windsurf rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseWindsurfRulesExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSWindsurfRulesExtractor()
        elif os_name == "Windows":
            return WindowsWindsurfRulesExtractor()
        elif os_name == "Linux":
            return LinuxWindsurfRulesExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class WindsurfMCPConfigExtractorFactory:
    """Factory for creating OS-specific Windsurf MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> BaseMCPConfigExtractor:
        """
        Create appropriate Windsurf MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance
            
        Raises:
            ValueError: If OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSWindsurfMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsWindsurfMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxWindsurfMCPConfigExtractor()
        else:
            raise ValueError(f"Unsupported operating system: {os_name}")


class RooMCPConfigExtractorFactory:
    """Factory for creating OS-specific Roo Code MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Roo Code MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSRooMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsRooMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxRooMCPConfigExtractor()
        else:
            return None


class RooRulesExtractorFactory:
    """Factory for creating OS-specific Roo Code rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseRooRulesExtractor]:
        """
        Create Roo Code rules extractor for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSRooRulesExtractor()
        elif os_name == "Windows":
            return WindowsRooRulesExtractor()
        elif os_name == "Linux":
            return LinuxRooRulesExtractor()
        else:
            return None


class ClineRulesExtractorFactory:
    """Factory for creating OS-specific Cline rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseClineRulesExtractor]:
        """
        Create appropriate Cline rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseClineRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClineRulesExtractor()
        elif os_name == "Windows":
            return WindowsClineRulesExtractor()
        elif os_name == "Linux":
            return LinuxClineRulesExtractor()
        else:
            return None


class ClineMCPConfigExtractorFactory:
    """Factory for creating OS-specific Cline MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Cline MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClineMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsClineMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxClineMCPConfigExtractor()
        else:
            return None


class AntigravityRulesExtractorFactory:
    """Factory for creating OS-specific Antigravity rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseAntigravityRulesExtractor]:
        """
        Create appropriate Antigravity rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseAntigravityRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSAntigravityRulesExtractor()
        elif os_name == "Windows":
            return WindowsAntigravityRulesExtractor()
        elif os_name == "Linux":
            return LinuxAntigravityRulesExtractor()
        else:
            return None


class AntigravityMCPConfigExtractorFactory:
    """Factory for creating OS-specific Antigravity MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Antigravity MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSAntigravityMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsAntigravityMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxAntigravityMCPConfigExtractor()
        else:
            return None


class KiloCodeRulesExtractorFactory:
    """Factory for creating OS-specific Kilo Code rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseKiloCodeRulesExtractor]:
        """
        Create appropriate Kilo Code rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseKiloCodeRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSKiloCodeRulesExtractor()
        elif os_name == "Windows":
            return WindowsKiloCodeRulesExtractor()
        elif os_name == "Linux":
            return LinuxKiloCodeRulesExtractor()
        else:
            return None


class KiloCodeMCPConfigExtractorFactory:
    """Factory for creating OS-specific Kilo Code MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Kilo Code MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSKiloCodeMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsKiloCodeMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxKiloCodeMCPConfigExtractor()
        else:
            return None


class GeminiCliRulesExtractorFactory:
    """Factory for creating OS-specific Gemini CLI rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseGeminiCliRulesExtractor]:
        """
        Create appropriate Gemini CLI rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseGeminiCliRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSGeminiCliRulesExtractor()
        elif os_name == "Windows":
            return WindowsGeminiCliRulesExtractor()
        elif os_name == "Linux":
            return LinuxGeminiCliRulesExtractor()
        else:
            return None


class GeminiCliMCPConfigExtractorFactory:
    """Factory for creating OS-specific Gemini CLI MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Gemini CLI MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSGeminiCliMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsGeminiCliMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxGeminiCliMCPConfigExtractor()
        else:
            return None


class CodexRulesExtractorFactory:
    """Factory for creating OS-specific Codex rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCodexRulesExtractor]:
        """
        Create appropriate Codex rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseCodexRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCodexRulesExtractor()
        elif os_name == "Windows":
            return WindowsCodexRulesExtractor()
        elif os_name == "Linux":
            return LinuxCodexRulesExtractor()
        else:
            return None


class CodexMCPConfigExtractorFactory:
    """Factory for creating OS-specific Codex MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Codex MCP config extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCodexMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsCodexMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxCodexMCPConfigExtractor()
        else:
            return None


class OpenCodeRulesExtractorFactory:
    """Factory for creating OS-specific OpenCode rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseOpenCodeRulesExtractor]:
        """
        Create appropriate OpenCode rules extractor for the OS.
        
        Args:
            os_name: Operating system name (defaults to current OS)
            
        Returns:
            BaseOpenCodeRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSOpenCodeRulesExtractor()
        elif os_name == "Windows":
            return WindowsOpenCodeRulesExtractor()
        elif os_name == "Linux":
            return LinuxOpenCodeRulesExtractor()
        else:
            return None


class OpenCodeMCPConfigExtractorFactory:
    """Factory for creating OS-specific OpenCode MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate OpenCode MCP config extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSOpenCodeMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsOpenCodeMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxOpenCodeMCPConfigExtractor()
        else:
            return None


class JetBrainsMCPConfigExtractorFactory:
    """Factory for creating OS-specific JetBrains MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate JetBrains MCP config extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSJetBrainsMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsJetBrainsMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxJetBrainsMCPConfigExtractor()
        else:
            return None


class GitHubCopilotMCPConfigExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create GitHub Copilot MCP config extractor for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSGitHubCopilotMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsGitHubCopilotMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxGitHubCopilotMCPConfigExtractor()
        else:
            return None


class CopilotCliMCPConfigExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot CLI MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create GitHub Copilot CLI MCP config extractor for the OS.

        The extraction logic is OS-agnostic (the all-users scan is handled by
        the shared root-support helper), so the Windows extractor is a thin
        subclass of the macOS one — see WindowsCopilotCliMCPConfigExtractor.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCopilotCliMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsCopilotCliMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxCopilotCliMCPConfigExtractor()
        else:
            return None


class CopilotCliRulesExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot CLI rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCopilotCliRulesExtractor]:
        """
        Create GitHub Copilot CLI rules extractor for the OS.

        The 6-source detection logic and the depth-bounded walk are shared in
        the macOS class; the Windows subclass overrides only the OS-specific
        seams (privilege check, all-users scan, filesystem root, top-level
        enumeration, system-dir skip) — see WindowsCopilotCliRulesExtractor.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCopilotCliRulesExtractor()
        elif os_name == "Windows":
            return WindowsCopilotCliRulesExtractor()
        elif os_name == "Linux":
            return LinuxCopilotCliRulesExtractor()
        else:
            return None


class CopilotCliSettingsExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot CLI settings extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCopilotCliSettingsExtractor]:
        """
        Create a GitHub Copilot CLI settings/permissions extractor for the OS.

        Reads the durable user-scope permission config (trusted folders, URL
        allow/deny); the only OS-specific seam is the all-users scan, so the
        Windows extractor is a thin subclass — see WindowsCopilotCliSettingsExtractor.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCopilotCliSettingsExtractor()
        elif os_name == "Windows":
            return WindowsCopilotCliSettingsExtractor()
        elif os_name == "Linux":
            return LinuxCopilotCliSettingsExtractor()
        else:
            return None


class CopilotCliSkillsExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot CLI skills extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCopilotCliSkillsExtractor]:
        """
        Create a GitHub Copilot CLI skills extractor for the OS.

        Reuses the shared skills engine; macOS and Windows are independent
        implementations (Windows parallelizes the walk with a thread pool) — see
        WindowsCopilotCliSkillsExtractor.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCopilotCliSkillsExtractor()
        elif os_name == "Windows":
            return WindowsCopilotCliSkillsExtractor()
        elif os_name == "Linux":
            return LinuxCopilotCliSkillsExtractor()
        else:
            return None


class GitHubCopilotRulesExtractorFactory:
    """Factory for creating OS-specific GitHub Copilot rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None):
        """
        Create GitHub Copilot rules extractor for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSGitHubCopilotRulesExtractor()
        elif os_name == "Windows":
            return WindowsGitHubCopilotRulesExtractor()
        elif os_name == "Linux":
            return LinuxGitHubCopilotRulesExtractor()
        else:
            return None


class JunieMCPConfigExtractorFactory:
    """Factory for creating OS-specific Junie MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Junie MCP config extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSJunieMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxJunieMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsJunieMCPConfigExtractor()
        else:
            return None


class JunieRulesExtractorFactory:
    """Factory for creating OS-specific Junie rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseJunieRulesExtractor]:
        """
        Create appropriate Junie rules extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseJunieRulesExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSJunieRulesExtractor()
        elif os_name == "Linux":
            return LinuxJunieRulesExtractor()
        elif os_name == "Windows":
            return WindowsJunieRulesExtractor()
        else:
            return None


class CursorCliSettingsExtractorFactory:
    """Factory for creating OS-specific Cursor CLI settings extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None):
        """
        Create appropriate Cursor CLI settings extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            Cursor CLI settings extractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorCliSettingsExtractor()
        elif os_name == "Windows":
            return WindowsCursorCliSettingsExtractor()
        elif os_name == "Linux":
            return LinuxCursorCliSettingsExtractor()
        else:
            return None


class CursorCliMCPConfigExtractorFactory:
    """Factory for creating OS-specific Cursor CLI MCP config extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseMCPConfigExtractor]:
        """
        Create appropriate Cursor CLI MCP config extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseMCPConfigExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorCliMCPConfigExtractor()
        elif os_name == "Windows":
            return WindowsCursorCliMCPConfigExtractor()
        elif os_name == "Linux":
            return LinuxCursorCliMCPConfigExtractor()
        else:
            return None


class CursorCliRulesExtractorFactory:
    """Factory for creating OS-specific Cursor CLI rules extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCursorCliRulesExtractor]:
        """
        Create appropriate Cursor CLI rules extractor for the OS.
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorCliRulesExtractor()
        elif os_name == "Windows":
            return WindowsCursorCliRulesExtractor()
        elif os_name == "Linux":
            return LinuxCursorCliRulesExtractor()
        else:
            return None


class ClaudeSkillsExtractorFactory:
    """Factory for creating OS-specific Claude Code skills extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseClaudeSkillsExtractor]:
        """
        Create appropriate Claude Code skills extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseClaudeSkillsExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeSkillsExtractor()
        elif os_name == "Windows":
            return WindowsClaudeSkillsExtractor()
        elif os_name == "Linux":
            return LinuxClaudeSkillsExtractor()
        else:
            return None


class CursorSkillsExtractorFactory:
    """Factory for creating OS-specific Cursor skills extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseCursorSkillsExtractor]:
        """
        Create appropriate Cursor skills extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseCursorSkillsExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSCursorSkillsExtractor()
        elif os_name == "Windows":
            return WindowsCursorSkillsExtractor()
        elif os_name == "Linux":
            return LinuxCursorSkillsExtractor()
        else:
            return None


class ClineSkillsExtractorFactory:
    """Factory for creating OS-specific Cline skills extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseClineSkillsExtractor]:
        """
        Create appropriate Cline skills extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseClineSkillsExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClineSkillsExtractor()
        elif os_name == "Windows":
            return WindowsClineSkillsExtractor()
        elif os_name == "Linux":
            return LinuxClineSkillsExtractor()
        else:
            return None


class ClaudeCoworkSkillsExtractorFactory:
    """Factory for creating OS-specific Claude Cowork skills extractors."""

    @staticmethod
    def create(os_name: Optional[str] = None) -> Optional[BaseClaudeCoworkSkillsExtractor]:
        """
        Create appropriate Claude Cowork skills extractor for the OS.

        Args:
            os_name: Operating system name (defaults to current OS)

        Returns:
            BaseClaudeCoworkSkillsExtractor instance or None if OS is not supported
        """
        if os_name is None:
            os_name = platform.system()

        if os_name == "Darwin":
            return MacOSClaudeCoworkSkillsExtractor()
        elif os_name == "Windows":
            return WindowsClaudeCoworkSkillsExtractor()
        elif os_name == "Linux":
            return LinuxClaudeCoworkSkillsExtractor()
        else:
            return None