devsync 0.5.5__py3-none-any.whl

aiconfigkit/ai_tools/translator.py

@@ -0,0 +1,390 @@
+"""Component translators for converting package components to IDE-specific formats."""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from aiconfigkit.core.models import (
+    AIToolType,
+    CommandComponent,
+    ComponentType,
+    HookComponent,
+    InstructionComponent,
+    MCPServerComponent,
+    ResourceComponent,
+)
+
+
+@dataclass
+class TranslatedComponent:
+    """
+    Result of translating a package component to IDE-specific format.
+
+    Contains the file content, target path, and any metadata needed
+    for installing the component to a specific IDE.
+    """
+
+    component_type: ComponentType
+    component_name: str
+    target_path: str
+    content: str
+    metadata: dict[str, Any] | None = None
+    needs_processing: bool = False
+
+    def __post_init__(self) -> None:
+        """Validate translated component."""
+        if not self.component_name:
+            raise ValueError("Component name cannot be empty")
+        if not self.target_path:
+            raise ValueError("Target path cannot be empty")
+
+
+class ComponentTranslator(ABC):
+    """
+    Abstract base class for translating package components to IDE-specific formats.
+
+    Each IDE (Cursor, Claude Code, Windsurf, Copilot) has a translator that
+    converts IDE-agnostic package components into the format expected by that IDE.
+    """
+
+    @property
+    @abstractmethod
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type this translator targets."""
+        pass
+
+    @abstractmethod
+    def translate_instruction(self, component: InstructionComponent, package_root: Path) -> TranslatedComponent:
+        """
+        Translate instruction component to IDE-specific format.
+
+        Args:
+            component: Instruction component from package
+            package_root: Root directory of the package
+
+        Returns:
+            Translated component ready for installation
+        """
+        pass
+
+    @abstractmethod
+    def translate_mcp_server(self, component: MCPServerComponent, package_root: Path) -> TranslatedComponent:
+        """
+        Translate MCP server component to IDE-specific format.
+
+        Args:
+            component: MCP server component from package
+            package_root: Root directory of the package
+
+        Returns:
+            Translated component ready for installation
+        """
+        pass
+
+    def translate_hook(self, component: HookComponent, package_root: Path) -> TranslatedComponent:
+        """
+        Translate hook component to IDE-specific format.
+
+        Args:
+            component: Hook component from package
+            package_root: Root directory of the package
+
+        Returns:
+            Translated component ready for installation
+
+        Raises:
+            NotImplementedError: If IDE doesn't support hooks
+        """
+        raise NotImplementedError(f"{self.tool_type.value} does not support hooks")
+
+    def translate_command(self, component: CommandComponent, package_root: Path) -> TranslatedComponent:
+        """
+        Translate command component to IDE-specific format.
+
+        Args:
+            component: Command component from package
+            package_root: Root directory of the package
+
+        Returns:
+            Translated component ready for installation
+
+        Raises:
+            NotImplementedError: If IDE doesn't support commands
+        """
+        raise NotImplementedError(f"{self.tool_type.value} does not support commands")
+
+    def translate_resource(self, component: ResourceComponent, package_root: Path) -> TranslatedComponent:
+        """
+        Translate resource component (generic file copy).
+
+        Args:
+            component: Resource component from package
+            package_root: Root directory of the package
+
+        Returns:
+            Translated component ready for installation
+        """
+        # For resources, we don't read the content here - it will be copied in installation
+        # Just provide the source path in metadata
+        resource_path = package_root / component.file
+
+        return TranslatedComponent(
+            component_type=ComponentType.RESOURCE,
+            component_name=component.name,
+            target_path=component.install_path,  # Use install_path instead of file
+            content="",  # Content not used - file will be copied directly
+            metadata={
+                "checksum": component.checksum,
+                "size": component.size,
+                "source_path": str(resource_path),  # Source file path for copying
+            },
+        )
+
+
+class CursorTranslator(ComponentTranslator):
+    """Translator for Cursor IDE (.cursor/rules/*.mdc)."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        return AIToolType.CURSOR
+
+    def translate_instruction(self, component: InstructionComponent, package_root: Path) -> TranslatedComponent:
+        """Translate instruction to Cursor .mdc format."""
+        # Read instruction content
+        instruction_path = package_root / component.file
+        with open(instruction_path, "r") as f:
+            content = f.read()
+
+        # Cursor uses .mdc files with optional frontmatter
+        # If instruction has tags, add them as metadata
+        if component.tags:
+            frontmatter = "---\n"
+            frontmatter += f"description: {component.description}\n"
+            frontmatter += f"tags: [{', '.join(component.tags)}]\n"
+            frontmatter += "---\n\n"
+            content = frontmatter + content
+
+        # Target path: .cursor/rules/name.mdc
+        target_path = f".cursor/rules/{component.name}.mdc"
+
+        return TranslatedComponent(
+            component_type=ComponentType.INSTRUCTION,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+        )
+
+    def translate_mcp_server(self, component: MCPServerComponent, package_root: Path) -> TranslatedComponent:
+        """Translate MCP server config to Cursor format."""
+        # Read MCP config
+        mcp_path = package_root / component.file
+        with open(mcp_path, "r") as f:
+            content = f.read()
+
+        # Store MCP config in project-specific location (.cursor/mcp/)
+        target_path = f".cursor/mcp/{component.name}.json"
+
+        return TranslatedComponent(
+            component_type=ComponentType.MCP_SERVER,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"credentials": [c.to_dict() for c in component.credentials]},
+        )
+
+
+class ClaudeCodeTranslator(ComponentTranslator):
+    """Translator for Claude Code (.claude/rules/*.md, .claude/hooks/, .claude/commands/)."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        return AIToolType.CLAUDE
+
+    def translate_instruction(self, component: InstructionComponent, package_root: Path) -> TranslatedComponent:
+        """Translate instruction to Claude Code .md format."""
+        # Read instruction content
+        instruction_path = package_root / component.file
+        with open(instruction_path, "r") as f:
+            content = f.read()
+
+        # Target path: .claude/rules/name.md
+        target_path = f".claude/rules/{component.name}.md"
+
+        return TranslatedComponent(
+            component_type=ComponentType.INSTRUCTION,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"tags": component.tags} if component.tags else None,
+        )
+
+    def translate_mcp_server(self, component: MCPServerComponent, package_root: Path) -> TranslatedComponent:
+        """Translate MCP server config to Claude Code format."""
+        # Read MCP config
+        mcp_path = package_root / component.file
+        with open(mcp_path, "r") as f:
+            content = f.read()
+
+        # Store MCP config in project-specific location
+        target_path = f".claude/mcp/{component.name}.json"
+
+        return TranslatedComponent(
+            component_type=ComponentType.MCP_SERVER,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"credentials": [c.to_dict() for c in component.credentials]},
+        )
+
+    def translate_hook(self, component: HookComponent, package_root: Path) -> TranslatedComponent:
+        """Translate hook script to Claude Code format."""
+        # Read hook script
+        hook_path = package_root / component.file
+        with open(hook_path, "r") as f:
+            content = f.read()
+
+        # Target path: .claude/hooks/name.sh (or appropriate extension)
+        file_ext = Path(component.file).suffix
+        target_path = f".claude/hooks/{component.name}{file_ext}"
+
+        return TranslatedComponent(
+            component_type=ComponentType.HOOK,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"hook_type": component.hook_type},
+        )
+
+    def translate_command(self, component: CommandComponent, package_root: Path) -> TranslatedComponent:
+        """Translate command script to Claude Code format."""
+        # Read command script
+        command_path = package_root / component.file
+        with open(command_path, "r") as f:
+            content = f.read()
+
+        # Target path: .claude/commands/name.sh (or appropriate extension)
+        file_ext = Path(component.file).suffix
+        target_path = f".claude/commands/{component.name}{file_ext}"
+
+        return TranslatedComponent(
+            component_type=ComponentType.COMMAND,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"command_type": component.command_type},
+        )
+
+
+class WindsurfTranslator(ComponentTranslator):
+    """Translator for Windsurf (.windsurf/rules/*.md)."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        return AIToolType.WINSURF
+
+    def translate_instruction(self, component: InstructionComponent, package_root: Path) -> TranslatedComponent:
+        """Translate instruction to Windsurf .md format."""
+        # Read instruction content
+        instruction_path = package_root / component.file
+        with open(instruction_path, "r") as f:
+            content = f.read()
+
+        # Target path: .windsurf/rules/name.md
+        target_path = f".windsurf/rules/{component.name}.md"
+
+        return TranslatedComponent(
+            component_type=ComponentType.INSTRUCTION,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+        )
+
+    def translate_mcp_server(self, component: MCPServerComponent, package_root: Path) -> TranslatedComponent:
+        """Translate MCP server config to Windsurf format."""
+        # Read MCP config
+        mcp_path = package_root / component.file
+        with open(mcp_path, "r") as f:
+            content = f.read()
+
+        # Store MCP config in project-specific location
+        target_path = f".windsurf/mcp/{component.name}.json"
+
+        return TranslatedComponent(
+            component_type=ComponentType.MCP_SERVER,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"credentials": [c.to_dict() for c in component.credentials]},
+        )
+
+
+class CopilotTranslator(ComponentTranslator):
+    """Translator for GitHub Copilot (.github/instructions/)."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        return AIToolType.COPILOT
+
+    def translate_instruction(self, component: InstructionComponent, package_root: Path) -> TranslatedComponent:
+        """Translate instruction to GitHub Copilot format."""
+        # Read instruction content
+        instruction_path = package_root / component.file
+        with open(instruction_path, "r") as f:
+            content = f.read()
+
+        # GitHub Copilot uses directory approach
+        # Target path: .github/instructions/name.md
+        target_path = f".github/instructions/{component.name}.md"
+
+        return TranslatedComponent(
+            component_type=ComponentType.INSTRUCTION,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+        )
+
+    def translate_mcp_server(self, component: MCPServerComponent, package_root: Path) -> TranslatedComponent:
+        """Translate MCP server config to VS Code/Copilot format."""
+        # Read MCP config
+        mcp_path = package_root / component.file
+        with open(mcp_path, "r") as f:
+            content = f.read()
+
+        # Store MCP config in project-specific location (.vscode/mcp/)
+        target_path = f".vscode/mcp/{component.name}.json"
+
+        return TranslatedComponent(
+            component_type=ComponentType.MCP_SERVER,
+            component_name=component.name,
+            target_path=target_path,
+            content=content,
+            metadata={"credentials": [c.to_dict() for c in component.credentials]},
+        )
+
+
+def get_translator(tool_type: AIToolType) -> ComponentTranslator:
+    """
+    Factory function to get translator for an AI tool.
+
+    Args:
+        tool_type: AI tool type
+
+    Returns:
+        ComponentTranslator instance for the tool
+
+    Raises:
+        ValueError: If tool type is not supported
+    """
+    translators: dict[AIToolType, type[ComponentTranslator]] = {
+        AIToolType.CURSOR: CursorTranslator,
+        AIToolType.CLAUDE: ClaudeCodeTranslator,
+        AIToolType.WINSURF: WindsurfTranslator,
+        AIToolType.COPILOT: CopilotTranslator,
+    }
+
+    translator_class = translators.get(tool_type)
+    if not translator_class:
+        raise ValueError(f"No translator found for tool type: {tool_type}")
+
+    return translator_class()

aiconfigkit/ai_tools/winsurf.py

@@ -0,0 +1,102 @@
+"""Winsurf 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_windsurf_mcp_config_path, get_winsurf_config_dir
+
+
+class WinsurfTool(AITool):
+    """Integration for Winsurf AI coding tool."""
+
+    @property
+    def tool_type(self) -> AIToolType:
+        """Return the AI tool type identifier."""
+        return AIToolType.WINSURF
+
+    @property
+    def tool_name(self) -> str:
+        """Return human-readable tool name."""
+        return "Windsurf"
+
+    def is_installed(self) -> bool:
+        """
+        Check if Windsurf is installed on the system.
+
+        Checks for existence of Windsurf configuration directory.
+
+        Returns:
+            True if Windsurf is detected
+        """
+        try:
+            config_dir = get_winsurf_config_dir()
+            # Check if parent directory exists
+            # Windsurf config dir structure: .../Windsurf/User/globalStorage
+            winsurf_base = config_dir.parent.parent
+            return winsurf_base.exists()
+        except Exception:
+            return False
+
+    def get_instructions_directory(self) -> Path:
+        """
+        Get the directory where Windsurf instructions should be installed.
+
+        Note: Windsurf uses ~/.windsurfrules as a single file for global rules.
+        This tool currently only supports project-level installations.
+
+        Returns:
+            Path to Windsurf instructions directory
+
+        Raises:
+            NotImplementedError: Global installation not supported for Windsurf
+        """
+        raise NotImplementedError(
+            f"{self.tool_name} global installation is not supported. "
+            "Windsurf uses a single ~/.windsurfrules file for global rules. "
+            "Please use project-level installation instead (--scope project)."
+        )
+
+    def get_instruction_file_extension(self) -> str:
+        """
+        Get the file extension for Windsurf instructions.
+
+        Windsurf uses markdown (.md) files for rules.
+
+        Returns:
+            File extension including the dot
+        """
+        return ".md"
+
+    def get_project_instructions_directory(self, project_root: Path) -> Path:
+        """
+        Get the directory for project-specific Windsurf instructions.
+
+        Windsurf stores project-specific rules in .windsurf/rules/ directory
+        in the project root. It supports multiple .md files in this directory.
+
+        Reference:
+        - Per-Project: .windsurf/rules/*.md (multiple files)
+        - Alternative: .windsurfrules (single file, not used by this tool)
+
+        Args:
+            project_root: Path to the project root directory
+
+        Returns:
+            Path to project instructions directory (.windsurf/rules/)
+        """
+        instructions_dir = project_root / ".windsurf" / "rules"
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+        return instructions_dir
+
+    def get_mcp_config_path(self) -> Path:
+        """
+        Get the path to the Windsurf MCP configuration file.
+
+        Note: Windsurf may add MCP support in the future.
+        We provide this for compatibility.
+
+        Returns:
+            Path to MCP configuration file
+        """
+        return get_windsurf_mcp_config_path()

aiconfigkit/cli/delete.py

@@ -0,0 +1,118 @@
+"""Delete command for removing instructions from library."""
+
+import typer
+from rich.console import Console
+from rich.prompt import Confirm
+
+from aiconfigkit.storage.library import LibraryManager
+from aiconfigkit.storage.tracker import InstallationTracker
+from aiconfigkit.utils.ui import print_error, print_success, print_warning
+
+console = Console()
+
+app = typer.Typer()
+
+
+def delete_from_library(
+    namespace: str,
+    force: bool = False,
+) -> int:
+    """
+    Delete a repository from the library.
+
+    Args:
+        namespace: Repository namespace to delete
+        force: Skip confirmation
+
+    Returns:
+        Exit code (0 = success)
+    """
+    library = LibraryManager()
+    tracker = InstallationTracker()
+
+    # Check if repository exists
+    repo = library.get_repository(namespace)
+    if not repo:
+        print_error(f"Repository not found: {namespace}")
+        print_error("Use 'instructionkit list library' to see available repositories")
+        return 1
+
+    # Check if any instructions from this repo are currently installed
+    installed_records = tracker.list_installations()
+    installed_from_repo = [
+        record for record in installed_records if any(inst.repo_namespace == namespace for inst in repo.instructions)
+    ]
+
+    if installed_from_repo and not force:
+        print_warning(
+            f"\n⚠️  Warning: {len(installed_from_repo)} instruction(s) from this repository are currently installed:"
+        )
+        for record in installed_from_repo[:5]:  # Show first 5
+            console.print(f"  - {record.instruction_name} ({record.ai_tool.value})")
+        if len(installed_from_repo) > 5:
+            console.print(f"  ... and {len(installed_from_repo) - 5} more")
+        console.print()
+        print_warning("Deleting from library will not uninstall them from your AI tools.\n")
+
+    # Confirm deletion
+    if not force:
+        console.print(f"\n[bold]Repository:[/bold] {repo.name}")
+        console.print(f"[bold]Namespace:[/bold] {repo.namespace}")
+        console.print(f"[bold]Instructions:[/bold] {len(repo.instructions)}\n")
+
+        confirmed = Confirm.ask("[yellow]Are you sure you want to delete this repository from your library?[/yellow]")
+
+        if not confirmed:
+            console.print("[dim]Cancelled[/dim]")
+            return 0
+
+    # Delete repository
+    success = library.remove_repository(namespace)
+
+    if success:
+        print_success(
+            f"✓ Deleted repository '{repo.name}' from library\n"
+            f"  {len(repo.instructions)} instruction(s) removed from library"
+        )
+        if installed_from_repo:
+            print_warning(
+                f"\n  Note: {len(installed_from_repo)} instruction(s) are still installed in your AI tools.\n"
+                f"  Use 'instructionkit uninstall <name>' to remove them."
+            )
+        return 0
+    else:
+        print_error(f"Failed to delete repository: {namespace}")
+        return 1
+
+
+@app.command(name="delete")
+def delete_command(
+    namespace: str = typer.Argument(
+        ...,
+        help="Repository namespace to delete from library",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        "-f",
+        help="Skip confirmation prompt",
+    ),
+) -> None:
+    """
+    Delete a repository from your local library.
+
+    This removes the downloaded instructions from your library but does NOT
+    uninstall them from your AI tools. To uninstall, use 'instructionkit uninstall'.
+
+    Examples:
+        # Delete a repository
+        instructionkit delete github.com_company_instructions
+
+        # Skip confirmation
+        instructionkit delete github.com_company_instructions --force
+
+        # List repositories to find namespace
+        instructionkit list library
+    """
+    exit_code = delete_from_library(namespace=namespace, force=force)
+    raise typer.Exit(code=exit_code)