devsync 0.5.5__py3-none-any.whl

aiconfigkit/utils/paths.py

@@ -0,0 +1,205 @@
+"""Cross-platform path utilities for AI coding tool directories."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+
+def get_home_directory() -> Path:
+    """Get user's home directory in a cross-platform way."""
+    return Path.home()
+
+
+def get_cursor_config_dir() -> Path:
+    """Get Cursor configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Cursor" / "User" / "globalStorage"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return home / "Library" / "Application Support" / "Cursor" / "User" / "globalStorage"
+        else:  # Linux
+            return home / ".config" / "Cursor" / "User" / "globalStorage"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_copilot_config_dir() -> Path:
+    """Get GitHub Copilot (VS Code) configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Code" / "User" / "globalStorage" / "github.copilot"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return home / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "github.copilot"
+        else:  # Linux
+            return home / ".config" / "Code" / "User" / "globalStorage" / "github.copilot"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_winsurf_config_dir() -> Path:
+    """Get Windsurf configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Windsurf" / "User" / "globalStorage"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return home / "Library" / "Application Support" / "Windsurf" / "User" / "globalStorage"
+        else:  # Linux
+            return home / ".config" / "Windsurf" / "User" / "globalStorage"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_kiro_config_dir() -> Path:
+    """Get Kiro configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Kiro" / "User" / "globalStorage"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return home / "Library" / "Application Support" / "Kiro" / "User" / "globalStorage"
+        else:  # Linux
+            return home / ".config" / "Kiro" / "User" / "globalStorage"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_cline_config_dir() -> Path:
+    """Get Cline (VS Code extension) configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return (
+                home / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev"
+            )
+        else:  # Linux
+            return home / ".config" / "Code" / "User" / "globalStorage" / "saoudrizwan.claude-dev"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_roo_config_dir() -> Path:
+    """Get Roo Code (VS Code extension) configuration directory based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Code" / "User" / "globalStorage" / "rooveterinaryinc.roo-cline"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return (
+                home
+                / "Library"
+                / "Application Support"
+                / "Code"
+                / "User"
+                / "globalStorage"
+                / "rooveterinaryinc.roo-cline"
+            )
+        else:  # Linux
+            return home / ".config" / "Code" / "User" / "globalStorage" / "rooveterinaryinc.roo-cline"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_claude_config_dir() -> Path:
+    """Get Claude Code configuration directory based on platform."""
+    home = get_home_directory()
+
+    # Claude Code uses ~/.claude/rules/ for global rules
+    # This is consistent across all platforms
+    return home / ".claude" / "rules"
+
+
+def get_claude_desktop_config_path() -> Path:
+    """Get Claude Desktop MCP configuration file path based on platform."""
+    home = get_home_directory()
+
+    if os.name == "nt":  # Windows
+        return home / "AppData" / "Roaming" / "Claude" / "claude_desktop_config.json"
+    elif os.name == "posix":
+        if "darwin" in os.uname().sysname.lower():  # macOS
+            return home / "Library" / "Application Support" / "Claude" / "claude_desktop_config.json"
+        else:  # Linux
+            return home / ".config" / "Claude" / "claude_desktop_config.json"
+
+    raise OSError(f"Unsupported operating system: {os.name}")
+
+
+def get_cursor_mcp_config_path() -> Path:
+    """Get Cursor MCP configuration file path based on platform."""
+    # Cursor doesn't natively support MCP yet, but we'll prepare for it
+    # Expected location would be similar to their settings structure
+    config_dir = get_cursor_config_dir()
+    return config_dir / "mcp_config.json"
+
+
+def get_windsurf_mcp_config_path() -> Path:
+    """Get Windsurf MCP configuration file path based on platform."""
+    # Windsurf may have MCP support in future
+    # Expected location would be similar to their settings structure
+    config_dir = get_winsurf_config_dir()
+    return config_dir / "mcp_config.json"
+
+
+def get_instructionkit_data_dir() -> Path:
+    """Get InstructionKit data directory for tracking installations."""
+    home = get_home_directory()
+    data_dir = home / ".instructionkit"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+
+def get_library_dir() -> Path:
+    """Get InstructionKit library directory for downloaded instructions."""
+    library_dir = get_instructionkit_data_dir() / "library"
+    library_dir.mkdir(parents=True, exist_ok=True)
+    return library_dir
+
+
+def get_installation_tracker_path() -> Path:
+    """Get path to installation tracking JSON file."""
+    return get_instructionkit_data_dir() / "installations.json"
+
+
+def ensure_directory_exists(path: Path) -> None:
+    """Ensure a directory exists, creating it if necessary."""
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def safe_file_name(name: str) -> str:
+    """Sanitize a string to be safe as a filename."""
+    # Replace unsafe characters with underscores
+    unsafe_chars = '<>:"/\\|?*'
+    safe_name = name
+    for char in unsafe_chars:
+        safe_name = safe_name.replace(char, "_")
+    return safe_name
+
+
+def resolve_conflict_name(original_path: Path, suffix: Optional[str] = None) -> Path:
+    """Generate a new path for conflict resolution with optional suffix."""
+    if suffix:
+        stem = original_path.stem
+        extension = original_path.suffix
+        new_name = f"{stem}-{suffix}{extension}"
+        return original_path.parent / new_name
+
+    # Auto-increment: file.md -> file-1.md -> file-2.md
+    counter = 1
+    while True:
+        stem = original_path.stem
+        extension = original_path.suffix
+        new_name = f"{stem}-{counter}{extension}"
+        new_path = original_path.parent / new_name
+        if not new_path.exists():
+            return new_path
+        counter += 1

aiconfigkit/utils/project.py

@@ -0,0 +1,109 @@
+"""Project detection utilities."""
+
+from pathlib import Path
+from typing import Optional
+
+
+def find_project_root(start_path: Optional[Path] = None) -> Optional[Path]:
+    """
+    Find the project root directory by looking for common project markers.
+
+    Searches upward from the start path for files/directories that indicate
+    a project root:
+    - .git directory (Git repository)
+    - pyproject.toml (Python project)
+    - package.json (Node.js project)
+    - Cargo.toml (Rust project)
+    - go.mod (Go project)
+    - pom.xml (Java/Maven project)
+    - build.gradle (Java/Gradle project)
+    - composer.json (PHP project)
+    - Gemfile (Ruby project)
+
+    Args:
+        start_path: Directory to start searching from. Defaults to current directory.
+
+    Returns:
+        Path to project root if found, None otherwise
+    """
+    if start_path is None:
+        start_path = Path.cwd()
+    else:
+        start_path = Path(start_path).resolve()
+
+    # Common project markers
+    markers = [
+        ".git",
+        "pyproject.toml",
+        "package.json",
+        "Cargo.toml",
+        "go.mod",
+        "pom.xml",
+        "build.gradle",
+        "composer.json",
+        "Gemfile",
+        ".project",  # Eclipse project
+        "Makefile",
+    ]
+
+    current = start_path
+
+    # Search upward through parent directories
+    while True:
+        for marker in markers:
+            marker_path = current / marker
+            if marker_path.exists():
+                return current
+
+        # Check if we've reached the filesystem root
+        parent = current.parent
+        if parent == current:
+            # No project root found
+            return None
+
+        current = parent
+
+
+def is_in_project() -> bool:
+    """
+    Check if the current directory is within a project.
+
+    Returns:
+        True if a project root can be found
+    """
+    return find_project_root() is not None
+
+
+def get_project_instructions_dir(project_root: Path, create: bool = True) -> Path:
+    """
+    Get the directory for project-specific instructions.
+
+    Creates a .instructionkit directory in the project root for storing
+    project-specific instructions and metadata.
+
+    Args:
+        project_root: Path to the project root directory
+        create: Whether to create the directory if it doesn't exist
+
+    Returns:
+        Path to project instructions directory
+    """
+    instructions_dir = project_root / ".instructionkit"
+
+    if create:
+        instructions_dir.mkdir(parents=True, exist_ok=True)
+
+    return instructions_dir
+
+
+def get_project_installation_tracker_path(project_root: Path) -> Path:
+    """
+    Get path to project-specific installation tracking file.
+
+    Args:
+        project_root: Path to the project root directory
+
+    Returns:
+        Path to project installation tracking JSON file
+    """
+    return get_project_instructions_dir(project_root) / "installations.json"

aiconfigkit/utils/streaming.py

@@ -0,0 +1,216 @@
+"""Streaming utilities for large file operations."""
+
+from pathlib import Path
+from typing import Callable, Optional
+
+
+class StreamingError(Exception):
+    """Raised when streaming operations fail."""
+
+    pass
+
+
+def stream_copy_file(
+    source: Path,
+    destination: Path,
+    chunk_size: int = 8192,
+    progress_callback: Optional[Callable[[int, int], None]] = None,
+) -> None:
+    """
+    Copy a file in streaming chunks for memory-efficient large file handling.
+
+    Args:
+        source: Source file path
+        destination: Destination file path
+        chunk_size: Size of chunks to read/write (default 8KB)
+        progress_callback: Optional callback for progress updates (bytes_copied, total_size)
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        StreamingError: If copy operation fails
+    """
+    if not source.exists():
+        raise FileNotFoundError(f"Source file not found: {source}")
+
+    try:
+        # Get total file size for progress tracking
+        total_size = source.stat().st_size
+        bytes_copied = 0
+
+        # Ensure destination directory exists
+        destination.parent.mkdir(parents=True, exist_ok=True)
+
+        # Open both files and copy in chunks
+        with open(source, "rb") as src_file:
+            with open(destination, "wb") as dst_file:
+                while True:
+                    chunk = src_file.read(chunk_size)
+                    if not chunk:
+                        break
+
+                    dst_file.write(chunk)
+                    bytes_copied += len(chunk)
+
+                    # Call progress callback if provided
+                    if progress_callback:
+                        progress_callback(bytes_copied, total_size)
+
+    except Exception as e:
+        # Clean up partial destination file on error
+        if destination.exists():
+            destination.unlink()
+        raise StreamingError(f"Failed to copy file: {e}") from e
+
+
+def stream_copy_with_verification(
+    source: Path,
+    destination: Path,
+    checksum: Optional[str] = None,
+    chunk_size: int = 8192,
+) -> bool:
+    """
+    Copy a file with optional checksum verification.
+
+    Args:
+        source: Source file path
+        destination: Destination file path
+        checksum: Expected SHA-256 checksum (optional)
+        chunk_size: Size of chunks to read/write
+
+    Returns:
+        True if copy and verification succeeded
+
+    Raises:
+        FileNotFoundError: If source file doesn't exist
+        StreamingError: If copy or verification fails
+    """
+    # First, copy the file
+    stream_copy_file(source, destination, chunk_size)
+
+    # Verify checksum if provided
+    if checksum:
+        from aiconfigkit.core.checksum import calculate_file_checksum
+
+        actual_checksum = calculate_file_checksum(str(destination), "sha256")
+
+        if actual_checksum.lower() != checksum.lower():
+            # Delete corrupted file
+            destination.unlink()
+            raise StreamingError(f"Checksum verification failed! " f"Expected: {checksum}, Actual: {actual_checksum}")
+
+    return True
+
+
+def get_file_size(file_path: Path) -> int:
+    """
+    Get file size in bytes.
+
+    Args:
+        file_path: Path to file
+
+    Returns:
+        File size in bytes
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    if not file_path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    return file_path.stat().st_size
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Format file size in human-readable format.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Formatted string (e.g., "1.5 MB", "100 KB")
+    """
+    units = ["B", "KB", "MB", "GB", "TB"]
+    size = float(size_bytes)
+    unit_index = 0
+
+    while size >= 1024 and unit_index < len(units) - 1:
+        size /= 1024
+        unit_index += 1
+
+    if unit_index == 0:
+        # Bytes - no decimal places
+        return f"{int(size)} {units[unit_index]}"
+    else:
+        # Other units - 1 decimal place
+        return f"{size:.1f} {units[unit_index]}"
+
+
+def is_large_file(file_path: Path, threshold_mb: int = 10) -> bool:
+    """
+    Check if file is considered "large" based on size threshold.
+
+    Args:
+        file_path: Path to file
+        threshold_mb: Size threshold in megabytes (default 10 MB)
+
+    Returns:
+        True if file size exceeds threshold
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    size_bytes = get_file_size(file_path)
+    threshold_bytes = threshold_mb * 1024 * 1024
+    return size_bytes > threshold_bytes
+
+
+def copy_directory_tree(
+    source: Path,
+    destination: Path,
+    progress_callback: Optional[Callable[[str, int, int], None]] = None,
+) -> int:
+    """
+    Copy an entire directory tree with progress tracking.
+
+    Args:
+        source: Source directory path
+        destination: Destination directory path
+        progress_callback: Optional callback(file_path, current, total)
+
+    Returns:
+        Number of files copied
+
+    Raises:
+        StreamingError: If copy operation fails
+    """
+    if not source.is_dir():
+        raise StreamingError(f"Source is not a directory: {source}")
+
+    try:
+        # Count total files for progress tracking
+        all_files = list(source.rglob("*"))
+        total_files = len([f for f in all_files if f.is_file()])
+        files_copied = 0
+
+        # Recreate directory structure
+        destination.mkdir(parents=True, exist_ok=True)
+
+        for item in all_files:
+            if item.is_file():
+                # Calculate relative path
+                rel_path = item.relative_to(source)
+                dest_file = destination / rel_path
+
+                # Copy file
+                stream_copy_file(item, dest_file)
+                files_copied += 1
+
+                # Call progress callback
+                if progress_callback:
+                    progress_callback(str(rel_path), files_copied, total_files)
+
+        return files_copied
+
+    except Exception as e:
+        raise StreamingError(f"Failed to copy directory tree: {e}") from e