devsync 0.5.5__py3-none-any.whl

aiconfigkit/ai_tools/cline.py

@@ -0,0 +1,92 @@
+"""Cline AI tool integration."""
+
+from pathlib import Path
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.core.models import AIToolType
+from aiconfigkit.utils.paths import get_cline_config_dir
+
+
+class ClineTool(AITool):
+    """Integration for Cline AI coding tool (VS Code extension).
+
+    Cline uses .clinerules/ directory at the project root for AI instructions.
+    Files are .md (Markdown) and are read recursively. Optional YAML frontmatter
+    with `paths:` field enables conditional rule activation based on file globs.
+
+    Detection is based on the VS Code extension saoudrizwan.claude-dev
+    globalStorage directory.
+    """
+
+    @property
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type identifier."""
+        return AIToolType.CLINE
+
+    @property
+    def tool_name(self) -> str:
+        """Return human-readable tool name."""
+        return "Cline"
+
+    def is_installed(self) -> bool:
+        """
+        Check if Cline is installed on the system.
+
+        Checks for existence of the Cline VS Code extension globalStorage directory
+        (saoudrizwan.claude-dev).
+
+        Returns:
+            True if Cline is detected
+        """
+        try:
+            config_dir = get_cline_config_dir()
+            return config_dir.exists()
+        except Exception:
+            return False
+
+    def get_instructions_directory(self) -> Path:
+        """
+        Get the directory where Cline instructions should be installed.
+
+        Note: Cline global rules live in ~/Documents/Cline/Rules/ but this
+        is non-standard. This tool only supports project-level installations.
+
+        Returns:
+            Path to Cline instructions directory
+
+        Raises:
+            NotImplementedError: Global installation not supported for Cline
+        """
+        raise NotImplementedError(
+            f"{self.tool_name} global installation is not supported. "
+            "Please use project-level installation instead (--scope project)."
+        )
+
+    def get_instruction_file_extension(self) -> str:
+        """
+        Get the file extension for Cline instructions.
+
+        Cline uses markdown (.md) files in the .clinerules/ directory.
+
+        Returns:
+            File extension including the dot
+        """
+        return ".md"
+
+    def get_project_instructions_directory(self, project_root: Path) -> Path:
+        """
+        Get the directory for project-specific Cline instructions.
+
+        Cline stores project-specific rules in .clinerules/ directory at the
+        project root. It reads .md files recursively from this directory.
+        Numeric prefixes (e.g., 01-coding-standards.md) control load order.
+
+        Args:
+            project_root: Path to the project root directory
+
+        Returns:
+            Path to project instructions directory (.clinerules/)
+        """
+        instructions_dir = project_root / ".clinerules"
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        return instructions_dir

aiconfigkit/ai_tools/copilot.py

@@ -0,0 +1,92 @@
+"""GitHub Copilot AI tool integration."""
+
+from pathlib import Path
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.core.models import AIToolType
+from aiconfigkit.utils.paths import get_copilot_config_dir
+
+
+class CopilotTool(AITool):
+    """Integration for GitHub Copilot (VS Code extension)."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type identifier."""
+        return AIToolType.COPILOT
+
+    @property
+    def tool_name(self) -> str:
+        """Return human-readable tool name."""
+        return "GitHub Copilot"
+
+    def is_installed(self) -> bool:
+        """
+        Check if GitHub Copilot is installed on the system.
+
+        Checks for existence of VS Code and Copilot extension directory.
+
+        Returns:
+            True if Copilot is detected
+        """
+        try:
+            config_dir = get_copilot_config_dir()
+            # Check if the Copilot extension directory exists
+            # VS Code structure: .../Code/User/globalStorage/github.copilot
+            return config_dir.parent.exists()
+        except Exception:
+            return False
+
+    def get_instructions_directory(self) -> Path:
+        """
+        Get the directory where Copilot instructions should be installed.
+
+        Note: GitHub Copilot uses .github/copilot-instructions.md as a single file
+        for project-level instructions. Global instructions are not officially supported.
+        This tool currently only supports project-level installations.
+
+        Returns:
+            Path to Copilot instructions directory
+
+        Raises:
+            NotImplementedError: Global installation not supported for GitHub Copilot
+        """
+        raise NotImplementedError(
+            f"{self.tool_name} global installation is not supported. "
+            "GitHub Copilot uses project-level instructions only. "
+            "Please use project-level installation instead (--scope project)."
+        )
+
+    def get_instruction_file_extension(self) -> str:
+        """
+        Get the file extension for Copilot instructions.
+
+        GitHub Copilot requires path-specific instructions to end with
+        .instructions.md per official documentation:
+        https://docs.github.com/en/copilot/how-tos/configure-custom-instructions/add-repository-instructions
+
+        Returns:
+            File extension including the dot
+        """
+        return ".instructions.md"
+
+    def get_project_instructions_directory(self, project_root: Path) -> Path:
+        """
+        Get the directory for project-specific Copilot instructions.
+
+        GitHub Copilot stores project-specific instructions in .github/instructions/
+        directory in the project root. It supports multiple .md files in this directory.
+
+        Reference:
+        - Path-specific: .github/instructions/*.instructions.md (multiple files)
+        - Alternative: .github/copilot-instructions.md (single file, not used by this tool)
+
+        Args:
+            project_root: Path to the project root directory
+
+        Returns:
+            Path to project instructions directory (.github/instructions/)
+        """
+        instructions_dir = project_root / ".github" / "instructions"
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        return instructions_dir

aiconfigkit/ai_tools/cursor.py

@@ -0,0 +1,109 @@
+"""Cursor AI tool integration."""
+
+from pathlib import Path
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.core.models import AIToolType
+from aiconfigkit.utils.paths import get_cursor_config_dir, get_cursor_mcp_config_path
+
+
+class CursorTool(AITool):
+    """Integration for Cursor AI coding tool."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type identifier."""
+        return AIToolType.CURSOR
+
+    @property
+    def tool_name(self) -> str:
+        """Return human-readable tool name."""
+        return "Cursor"
+
+    def is_installed(self) -> bool:
+        """
+        Check if Cursor is installed on the system.
+
+        Checks for existence of Cursor configuration directory.
+
+        Returns:
+            True if Cursor is detected
+        """
+        try:
+            config_dir = get_cursor_config_dir()
+            # Check if parent directory exists (not necessarily the full path)
+            # Cursor config dir structure: .../Cursor/User/globalStorage
+            cursor_base = config_dir.parent.parent
+            return cursor_base.exists()
+        except Exception:
+            return False
+
+    def get_instructions_directory(self) -> Path:
+        """
+        Get the directory where Cursor instructions should be installed.
+
+        Note: Cursor uses .cursorrules as a single file for global rules.
+        This tool currently only supports project-level installations.
+
+        Returns:
+            Path to Cursor instructions directory
+
+        Raises:
+            NotImplementedError: Global installation not supported for Cursor
+        """
+        raise NotImplementedError(
+            f"{self.tool_name} global installation is not supported. "
+            "Cursor uses a single .cursorrules file for global rules. "
+            "Please use project-level installation instead (--scope project)."
+        )
+
+    def get_instruction_file_extension(self) -> str:
+        """
+        Get the file extension for Cursor instructions.
+
+        Cursor uses .mdc files (markdown with metadata) for rules.
+
+        Returns:
+            File extension including the dot
+        """
+        return ".mdc"
+
+    def get_project_instructions_directory(self, project_root: Path) -> Path:
+        """
+        Get the directory for project-specific Cursor instructions.
+
+        Cursor stores project-specific rules in .cursor/rules/ directory
+        in the project root. It supports multiple .mdc files in this directory.
+
+        Reference:
+        - Recommended: .cursor/rules/*.mdc (multiple files with metadata)
+        - Alternative: .cursorrules (single file, not used by this tool)
+
+        .mdc files can include metadata like:
+        ---
+        description: Rule description
+        globs: ["src/**/*.tsx"]
+        alwaysApply: true
+        ---
+
+        Args:
+            project_root: Path to the project root directory
+
+        Returns:
+            Path to project instructions directory (.cursor/rules/)
+        """
+        instructions_dir = project_root / ".cursor" / "rules"
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        return instructions_dir
+
+    def get_mcp_config_path(self) -> Path:
+        """
+        Get the path to the Cursor MCP configuration file.
+
+        Note: Cursor doesn't natively support MCP yet, but we provide this
+        for future compatibility.
+
+        Returns:
+            Path to MCP configuration file
+        """
+        return get_cursor_mcp_config_path()

aiconfigkit/ai_tools/detector.py

@@ -0,0 +1,169 @@
+"""AI tool detection and auto-discovery."""
+
+from typing import Optional
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.ai_tools.claude import ClaudeTool
+from aiconfigkit.ai_tools.cline import ClineTool
+from aiconfigkit.ai_tools.copilot import CopilotTool
+from aiconfigkit.ai_tools.cursor import CursorTool
+from aiconfigkit.ai_tools.kiro import KiroTool
+from aiconfigkit.ai_tools.roo import RooTool
+from aiconfigkit.ai_tools.winsurf import WinsurfTool
+from aiconfigkit.core.models import AIToolType
+
+
+class AIToolDetector:
+    """Detect and manage AI coding tools."""
+
+    def __init__(self) -> None:
+        """Initialize detector with all supported tools."""
+        self.tools: dict[AIToolType, AITool] = {
+            AIToolType.CURSOR: CursorTool(),
+            AIToolType.COPILOT: CopilotTool(),
+            AIToolType.WINSURF: WinsurfTool(),
+            AIToolType.CLAUDE: ClaudeTool(),
+            AIToolType.KIRO: KiroTool(),
+            AIToolType.CLINE: ClineTool(),
+            AIToolType.ROO: RooTool(),
+        }
+
+    def detect_installed_tools(self) -> list[AITool]:
+        """
+        Detect all installed AI coding tools.
+
+        Returns:
+            List of installed AITool instances
+        """
+        installed = []
+        for tool in self.tools.values():
+            if tool.is_installed():
+                installed.append(tool)
+        return installed
+
+    def get_tool_by_name(self, name: str) -> Optional[AITool]:
+        """
+        Get AI tool instance by name.
+
+        Args:
+            name: Tool name (cursor, copilot, winsurf, claude)
+
+        Returns:
+            AITool instance or None if not found
+        """
+        try:
+            tool_type = AIToolType(name.lower())
+            return self.tools.get(tool_type)
+        except ValueError:
+            return None
+
+    def get_tool_by_type(self, tool_type: AIToolType) -> Optional[AITool]:
+        """
+        Get AI tool instance by type.
+
+        Args:
+            tool_type: AIToolType enum value
+
+        Returns:
+            AITool instance
+        """
+        return self.tools.get(tool_type)
+
+    def get_primary_tool(self) -> Optional[AITool]:
+        """
+        Get the primary (first detected) AI tool.
+
+        Priority order: Cursor, Copilot, Winsurf, Claude Code
+
+        Returns:
+            First installed AITool or None if none installed
+        """
+        # Check in priority order
+        priority = [
+            AIToolType.CURSOR,
+            AIToolType.COPILOT,
+            AIToolType.WINSURF,
+            AIToolType.CLAUDE,
+            AIToolType.KIRO,
+            AIToolType.CLINE,
+            AIToolType.ROO,
+        ]
+
+        for tool_type in priority:
+            tool = self.tools[tool_type]
+            if tool.is_installed():
+                return tool
+
+        return None
+
+    def is_any_tool_installed(self) -> bool:
+        """
+        Check if any AI coding tool is installed.
+
+        Returns:
+            True if at least one tool is detected
+        """
+        return len(self.detect_installed_tools()) > 0
+
+    def get_tool_names(self) -> list[str]:
+        """
+        Get list of all supported tool names.
+
+        Returns:
+            List of tool name strings
+        """
+        return [tool_type.value for tool_type in self.tools.keys()]
+
+    def validate_tool_name(self, name: str) -> bool:
+        """
+        Validate if tool name is supported.
+
+        Args:
+            name: Tool name to validate
+
+        Returns:
+            True if tool is supported
+        """
+        return name.lower() in self.get_tool_names()
+
+    def get_detection_summary(self) -> dict[str, bool]:
+        """
+        Get detection summary for all tools.
+
+        Returns:
+            Dictionary mapping tool names to installation status
+        """
+        return {tool_type.value: tool.is_installed() for tool_type, tool in self.tools.items()}
+
+    def format_detection_summary(self) -> str:
+        """
+        Format detection summary as human-readable string.
+
+        Returns:
+            Formatted summary string
+        """
+        summary = self.get_detection_summary()
+        lines = ["AI Coding Tools Detection:"]
+
+        for tool_name, is_installed in summary.items():
+            status = "✓ Installed" if is_installed else "✗ Not found"
+            lines.append(f"  {tool_name.capitalize()}: {status}")
+
+        return "\n".join(lines)
+
+
+# Singleton instance for convenience
+_detector_instance: Optional[AIToolDetector] = None
+
+
+def get_detector() -> AIToolDetector:
+    """
+    Get singleton AIToolDetector instance.
+
+    Returns:
+        AIToolDetector instance
+    """
+    global _detector_instance
+    if _detector_instance is None:
+        _detector_instance = AIToolDetector()
+    return _detector_instance

aiconfigkit/ai_tools/kiro.py

@@ -0,0 +1,85 @@
+"""Kiro AI tool integration."""
+
+from pathlib import Path
+
+from aiconfigkit.ai_tools.base import AITool
+from aiconfigkit.core.models import AIToolType
+from aiconfigkit.utils.paths import get_kiro_config_dir
+
+
+class KiroTool(AITool):
+    """Integration for Kiro AI coding tool."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type identifier."""
+        return AIToolType.KIRO
+
+    @property
+    def tool_name(self) -> str:
+        """Return human-readable tool name."""
+        return "Kiro"
+
+    def is_installed(self) -> bool:
+        """
+        Check if Kiro is installed on the system.
+
+        Checks for existence of Kiro configuration directory.
+
+        Returns:
+            True if Kiro is detected
+        """
+        try:
+            config_dir = get_kiro_config_dir()
+            # Check if parent directory exists
+            # Kiro config dir structure: .../Kiro/User/globalStorage
+            kiro_base = config_dir.parent.parent
+            return kiro_base.exists()
+        except Exception:
+            return False
+
+    def get_instructions_directory(self) -> Path:
+        """
+        Get the directory where Kiro instructions should be installed.
+
+        Note: Kiro uses ~/.kiro/steering/ for global steering files.
+        This tool currently only supports project-level installations.
+
+        Returns:
+            Path to Kiro instructions directory
+
+        Raises:
+            NotImplementedError: Global installation not supported for Kiro
+        """
+        raise NotImplementedError(
+            f"{self.tool_name} global installation is not supported. "
+            "Please use project-level installation instead (--scope project)."
+        )
+
+    def get_instruction_file_extension(self) -> str:
+        """
+        Get the file extension for Kiro instructions.
+
+        Kiro uses markdown (.md) files for steering.
+
+        Returns:
+            File extension including the dot
+        """
+        return ".md"
+
+    def get_project_instructions_directory(self, project_root: Path) -> Path:
+        """
+        Get the directory for project-specific Kiro instructions.
+
+        Kiro stores project-specific steering files in .kiro/steering/ directory
+        in the project root. It supports multiple .md files in this directory.
+
+        Args:
+            project_root: Path to the project root directory
+
+        Returns:
+            Path to project instructions directory (.kiro/steering/)
+        """
+        instructions_dir = project_root / ".kiro" / "steering"
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        return instructions_dir