@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/lsp_orchestrator/src/vds_lsp_orchestrator/utils.py

@@ -1,959 +0,0 @@
-"""Utility functions for configuration and environment."""
-
-import difflib
-import json
-import logging
-import os
-import platform
-import shutil
-import tomllib
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Literal
-from urllib.parse import unquote, urlparse
-
-from pydantic import BaseModel, Field, ValidationError
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass(frozen=True)
-class ProjectTools:
-    """Detected project tools and configuration.
-
-    Attributes:
-        package_manager: The package manager used by the project.
-        type_checker: The type checker configured for the project.
-        formatter: The code formatter configured for the project.
-        linter: The linter configured for the project.
-        test_runner: The test runner used by the project.
-        coverage_tool: The coverage tool configured for the project.
-
-    Examples:
-        >>> tools = ProjectTools(
-        ...     package_manager="uv",
-        ...     type_checker="basedpyright",
-        ...     formatter="ruff",
-        ...     linter="ruff",
-        ...     test_runner="pytest",
-        ...     coverage_tool="coverage"
-        ... )
-        >>> tools.get_install_command()
-        'uv sync'
-    """
-
-    package_manager: Literal["uv", "poetry", "pdm", "hatch", "pipenv", "pip", "unknown"] = "unknown"
-    type_checker: Literal["mypy", "basedpyright", "pyright", "none"] = "none"
-    formatter: Literal["ruff", "black", "none"] = "none"
-    linter: Literal["ruff", "pylint", "flake8", "none"] = "none"
-    test_runner: Literal["pytest", "unittest", "none"] = "none"
-    coverage_tool: Literal["coverage", "none"] = "none"
-
-    def get_install_command(self) -> str:
-        """Return the appropriate install command based on package manager.
-
-        Returns:
-            The shell command to install project dependencies.
-
-        Examples:
-            >>> tools = ProjectTools(
-            ...     package_manager="uv",
-            ...     type_checker="basedpyright",
-            ...     formatter="ruff",
-            ...     linter="ruff",
-            ...     test_runner="pytest",
-            ...     coverage_tool="coverage"
-            ... )
-            >>> tools.get_install_command()
-            'uv sync'
-        """
-        match self.package_manager:
-            case "uv":
-                return "uv sync"
-            case "poetry":
-                return "poetry install"
-            case "pdm":
-                return "pdm install"
-            case "hatch":
-                return "hatch env create"
-            case "pipenv":
-                return "pipenv install"
-            case _:
-                return "pip install -e ."
-
-    def get_test_command(self) -> str:
-        """Return the appropriate test command based on test runner.
-
-        Returns:
-            The shell command to run tests.
-
-        Examples:
-            >>> tools = ProjectTools(
-            ...     package_manager="uv",
-            ...     type_checker="basedpyright",
-            ...     formatter="ruff",
-            ...     linter="ruff",
-            ...     test_runner="pytest",
-            ...     coverage_tool="coverage"
-            ... )
-            >>> tools.get_test_command()
-            'pytest'
-        """
-        match self.test_runner:
-            case "pytest":
-                return "pytest"
-            case "unittest":
-                return "python -m unittest"
-            case _:
-                return ""
-
-    def get_format_command(self) -> str | None:
-        """Return the appropriate format command based on formatter.
-
-        Returns:
-            Command string to format code, or None if no formatter detected.
-
-        Examples:
-            >>> tools = ProjectTools(formatter="ruff", ...)
-            >>> tools.get_format_command()
-            'ruff format'
-            >>> tools = ProjectTools(formatter="none", ...)
-            >>> tools.get_format_command()
-            None
-        """
-        commands: dict[str, str | None] = {
-            "ruff": "ruff format",
-            "black": "black .",
-            "none": None,
-        }
-        return commands.get(self.formatter)
-
-    def get_lint_command(self) -> str | None:
-        """Return the appropriate lint command based on linter.
-
-        Returns:
-            Command string to lint code, or None if no linter detected.
-
-        Examples:
-            >>> tools = ProjectTools(linter="ruff", ...)
-            >>> tools.get_lint_command()
-            'ruff check'
-            >>> tools = ProjectTools(linter="none", ...)
-            >>> tools.get_lint_command()
-            None
-        """
-        commands: dict[str, str | None] = {
-            "ruff": "ruff check",
-            "pylint": "pylint",
-            "flake8": "flake8",
-            "none": None,
-        }
-        return commands.get(self.linter)
-
-
-def is_wsl2() -> bool:
-    """Detect if running under WSL2 (Windows Subsystem for Linux).
-
-    WSL2 has different filesystem performance characteristics,
-    especially when accessing Windows files via /mnt/c/.
-
-    Returns:
-        True if running under WSL2, False otherwise.
-
-    Detection methods (in order of reliability):
-    1. Check /proc/version for "Microsoft" or "WSL" strings
-    2. Check platform.uname().release for "microsoft" string
-    3. Check if wsl.exe is available (Windows calling into WSL)
-
-    Examples:
-        >>> is_wsl2()
-        True  # Running under WSL2
-        >>> is_wsl2()
-        False  # Running on native Linux
-    """
-    # Method 1: Check /proc/version (most reliable for WSL2)
-    proc_version = Path("/proc/version")
-    if proc_version.exists():
-        try:
-            version_content = proc_version.read_text().lower()
-            if "microsoft" in version_content or "wsl" in version_content:
-                logger.debug("WSL2 detected via /proc/version")
-                return True
-        except OSError:
-            pass
-
-    # Method 2: Check platform.uname().release
-    # WSL2 kernels typically have "-microsoft" in the release string
-    try:
-        release = platform.uname().release.lower()
-        if "microsoft" in release or "wsl" in release:
-            logger.debug("WSL2 detected via platform.uname().release")
-            return True
-    except OSError, AttributeError:
-        pass
-
-    # Method 3: Check if wsl.exe is available
-    # This indicates we're on Windows or can call Windows tools
-    if shutil.which("wsl.exe"):
-        logger.debug("WSL detected via wsl.exe availability")
-        return True
-
-    return False
-
-
-def is_wsl_path(path: Path) -> bool:
-    """Check if a path is a WSL mount point (e.g., /mnt/c/, /mnt/d/).
-
-    WSL2 mount points for Windows drives have significantly slower
-    filesystem performance than native WSL filesystem.
-
-    Args:
-        path: Path to check
-
-    Returns:
-        True if path is under /mnt/ (Windows filesystem from WSL)
-
-    Examples:
-        >>> is_wsl_path(Path("/mnt/c/Users"))
-        True
-        >>> is_wsl_path(Path("/home/user/project"))
-        False
-    """
-    try:
-        # Convert to absolute path for reliable checking
-        abs_path = path.resolve()
-        # Check if path starts with /mnt/ (Windows drives mount point)
-        return str(abs_path).startswith("/mnt/")
-    except OSError, RuntimeError:
-        return False
-
-
-def wsl_path_to_windows(path: Path) -> str:
-    """Convert a WSL path to Windows path format.
-
-    Args:
-        path: WSL path (e.g., /mnt/c/Users/project)
-
-    Returns:
-        Windows path (e.g., C:\\Users\\project)
-
-    Examples:
-        >>> wsl_path_to_windows(Path("/mnt/c/Users/project"))
-        'C:\\Users\\project'
-    """
-    abs_path = str(path.resolve())
-    if abs_path.startswith("/mnt/"):
-        # Extract drive letter and rest of path
-        parts = abs_path[5:].split("/", 1)
-        if len(parts) == 2:
-            drive, rest = parts
-            # Convert to Windows path format
-            windows_path = f"{drive.upper()}:\\"
-            if rest:
-                windows_path += rest.replace("/", "\\")
-            return windows_path
-    return abs_path
-
-
-def windows_path_to_wsl(path: str) -> Path:
-    """Convert a Windows path to WSL path format.
-
-    Args:
-        path: Windows path (e.g., C:\\Users\\project)
-
-    Returns:
-        WSL path (e.g., /mnt/c/Users/project)
-
-    Examples:
-        >>> windows_path_to_wsl("C:\\Users\\project")
-        Path('/mnt/c/Users/project')
-    """
-    # Handle both backslash and forward slash separators
-    path = path.replace("\\", "/")
-    # Match pattern: C:/ or C: at the start
-    if len(path) >= 2 and path[1] == ":":
-        drive = path[0].lower()
-        rest = path[2:] if len(path) > 2 else ""
-        return Path(f"/mnt/{drive}{rest}")
-    return Path(path)
-
-
-class LspConfig(BaseModel):
-    """LSP Orchestrator Configuration."""
-
-    model_config = {"extra": "allow"}
-
-    # Server settings
-    server_path: str | None = None
-    enable_ruff_lsp: bool = False
-    ruff_server_path: str | None = None
-    fixes_allow_unsafe: bool = False
-    enable_language_services: bool = True
-    notebook_support: bool = True
-    timeout: int = 60
-    log_level: str | None = None
-    config_file: Path | None = None
-    basedpyright_path: str | None = None
-    basedpyright_config: dict[str, Any] = Field(default_factory=dict)
-    basedpyright_config_path: Path | None = None
-    venv_path: str | None = None
-    venv: str | None = None
-
-    # Type checker settings
-    type_checker: Literal["auto", "mypy", "basedpyright", "pyright", "pylsp"] = "auto"
-
-    # Docker settings
-    docker_mode: bool = False
-    docker_image: str = "vds-lsp-orchestrator:latest"
-    docker_workspace: str | None = None
-
-    # Indexer settings
-    cache_dir: Path | None = None
-    exclude_patterns: list[str] = Field(
-        default_factory=lambda: [
-            "**/node_modules/**",
-            "**/.venv/**",
-            "**/__pycache__/**",
-            "**/build/**",
-            "**/dist/**",
-        ],
-    )
-
-    # Analysis settings
-    type_checking_mode: str = "standard"  # standard, strict, basic
-    diagnostic_mode: str = "openFilesOnly"  # openFilesOnly, workspace
-    auto_format_strings: bool = True  # Auto-convert strings to f-strings when typing {
-
-    # AI settings
-    json_pretty: bool = False
-
-    # Daemon settings
-    daemon_enabled: bool = False
-    daemon_idle_timeout: int = 300
-    daemon_max_clients: int = 10
-    hot_reload: bool = True
-
-    # WSL2 settings
-    wsl_optimize: bool = False
-
-
-def _read_json_file(path: Path) -> dict[str, Any] | None:
-    try:
-        return json.loads(path.read_text())
-    except FileNotFoundError:
-        return None
-    except json.JSONDecodeError as exc:
-        logger.warning("Failed to parse JSON config %s: %s", path, exc)
-        return None
-    except Exception as exc:
-        logger.warning("Failed to read JSON config %s: %s", path, exc)
-        return None
-
-
-def _read_toml_file(path: Path) -> dict[str, Any] | None:
-    try:
-        return tomllib.loads(path.read_text())
-    except FileNotFoundError:
-        return None
-    except Exception as exc:
-        logger.warning("Failed to read TOML config %s: %s", path, exc)
-        return None
-
-
-def _normalize_vds_config(raw: dict[str, Any]) -> dict[str, Any]:
-    normalized: dict[str, Any] = {}
-    mapping = {
-        "lsp_server": "server_path",
-        "server_path": "server_path",
-        "server": "server_path",
-        "enable_ruff_lsp": "enable_ruff_lsp",
-        "ruff_server_path": "ruff_server_path",
-        "fixes_allow_unsafe": "fixes_allow_unsafe",
-        "enable_language_services": "enable_language_services",
-        "notebook_support": "notebook_support",
-        "cache_dir": "cache_dir",
-        "timeout": "timeout",
-        "exclude_patterns": "exclude_patterns",
-        "type_checking_mode": "type_checking_mode",
-        "diagnostic_mode": "diagnostic_mode",
-        "auto_format_strings": "auto_format_strings",
-        "json_pretty": "json_pretty",
-        "basedpyright_path": "basedpyright_path",
-        "log_level": "log_level",
-        "config_file": "config_file",
-        "venv_path": "venv_path",
-        "venv": "venv",
-        "daemon_enabled": "daemon_enabled",
-        "daemon_idle_timeout": "daemon_idle_timeout",
-        "daemon_max_clients": "daemon_max_clients",
-        "max_clients": "daemon_max_clients",  # Alias for daemon_max_clients
-        "hot_reload": "hot_reload",
-        "wsl_optimize": "wsl_optimize",
-        "docker_mode": "docker_mode",
-        "docker_image": "docker_image",
-        "docker_workspace": "docker_workspace",
-        "type_checker": "type_checker",
-        "typechecker": "type_checker",  # Alternate casing
-    }
-    for key, value in raw.items():
-        # First try direct lookup with hyphens replaced by underscores
-        key_norm = key.replace("-", "_")
-        target = mapping.get(key_norm)
-        if target:
-            normalized[target] = value
-            continue
-
-        # Try camelCase to snake_case conversion for JSON config
-        # e.g., typeChecker -> type_checker
-        import re
-
-        # Convert camelCase to snake_case
-        key_snake = re.sub(r"(?<!^)(?=[A-Z])", "_", key).lower()
-        target = mapping.get(key_snake)
-        if target:
-            normalized[target] = value
-
-    return normalized
-
-
-def _load_basedpyright_config(
-    *,
-    root_path: Path,
-    config_file: Path | None,
-    pyproject_data: dict[str, Any] | None,
-) -> tuple[dict[str, Any], Path | None]:
-    base_config: dict[str, Any] = {}
-    source_path: Path | None = None
-
-    if config_file:
-        source_path = config_file
-        config_data = _read_json_file(config_file)
-        if config_data:
-            base_config.update(config_data)
-    else:
-        pyright_config = root_path / "pyrightconfig.json"
-        basedpyright_config = root_path / ".basedpyright"
-        if pyright_config.exists():
-            source_path = pyright_config
-            config_data = _read_json_file(pyright_config)
-            if config_data:
-                base_config.update(config_data)
-        elif basedpyright_config.exists():
-            source_path = basedpyright_config
-            config_data = _read_json_file(basedpyright_config)
-            if config_data:
-                base_config.update(config_data)
-
-    if pyproject_data:
-        tool_section = pyproject_data.get("tool", {})
-        toml_basedpyright = tool_section.get("basedpyright", {})
-        if isinstance(toml_basedpyright, dict):
-            for key, value in toml_basedpyright.items():
-                key_norm = key.replace("-", "_")
-                if key_norm == "typecheckingmode":
-                    base_config.setdefault("typeCheckingMode", value)
-                elif key_norm == "venvpath":
-                    base_config.setdefault("venvPath", value)
-                elif key_norm == "venv":
-                    base_config.setdefault("venv", value)
-                else:
-                    base_config.setdefault(key, value)
-
-    return base_config, source_path
-
-
-def _configure_logging(level: str) -> None:
-    try:
-        log_level = getattr(logging, level.upper())
-    except AttributeError:
-        logger.warning("Unknown log level %s; falling back to INFO", level)
-        log_level = logging.INFO
-    logging.basicConfig(level=log_level)
-
-
-def load_config(
-    root_path: Path,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> LspConfig:
-    """Load configuration from multiple sources.
-
-    Priority:
-    1. .vds-lsp/config.json
-    2. pyproject.toml ([tool.vds-lsp])
-    3. Environment variables (VDS_LSP_*)
-    4. CLI overrides
-    5. Defaults
-    """
-    config_data: dict[str, Any] = {}
-
-    pyproject_path = root_path / "pyproject.toml"
-    pyproject_data = _read_toml_file(pyproject_path)
-
-    # 1. Load from file (.vds-lsp/config.json)
-    vds_config_path = root_path / ".vds-lsp" / "config.json"
-    vds_config_data = _read_json_file(vds_config_path)
-    if vds_config_data:
-        config_data.update(_normalize_vds_config(vds_config_data))
-
-    # 2. Load from pyproject.toml ([tool.vds-lsp])
-    if pyproject_data:
-        tool_section = pyproject_data.get("tool", {})
-        vds_section = tool_section.get("vds-lsp", {}) or tool_section.get("vds_lsp", {})
-        if isinstance(vds_section, dict):
-            config_data.update(_normalize_vds_config(vds_section))
-
-    # 3. Load from env vars (override files)
-    if os.environ.get("VDS_LSP_SERVER"):
-        config_data["server_path"] = os.environ["VDS_LSP_SERVER"]
-
-    if os.environ.get("VDS_LSP_ENABLE_RUFF_LSP"):
-        config_data["enable_ruff_lsp"] = os.environ["VDS_LSP_ENABLE_RUFF_LSP"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_RUFF_SERVER"):
-        config_data["ruff_server_path"] = os.environ["VDS_LSP_RUFF_SERVER"]
-
-    if os.environ.get("VDS_LSP_FIXES_ALLOW_UNSAFE"):
-        config_data["fixes_allow_unsafe"] = os.environ["VDS_LSP_FIXES_ALLOW_UNSAFE"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_ENABLE_LANGUAGE_SERVICES"):
-        config_data["enable_language_services"] = os.environ[
-            "VDS_LSP_ENABLE_LANGUAGE_SERVICES"
-        ].lower() in ("true", "1", "yes")
-
-    if os.environ.get("VDS_LSP_NOTEBOOK_SUPPORT"):
-        config_data["notebook_support"] = os.environ["VDS_LSP_NOTEBOOK_SUPPORT"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_TIMEOUT"):
-        try:
-            config_data["timeout"] = int(os.environ["VDS_LSP_TIMEOUT"])
-        except ValueError as exc:
-            logger.warning("Invalid VDS_LSP_TIMEOUT: %s", exc)
-
-    if os.environ.get("VDS_LSP_CACHE_DIR"):
-        config_data["cache_dir"] = Path(os.environ["VDS_LSP_CACHE_DIR"])
-
-    if os.environ.get("VDS_LSP_JSON_PRETTY"):
-        config_data["json_pretty"] = os.environ["VDS_LSP_JSON_PRETTY"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_LOG_LEVEL"):
-        config_data["log_level"] = os.environ["VDS_LSP_LOG_LEVEL"]
-
-    if os.environ.get("VDS_LSP_DAEMON_ENABLED"):
-        config_data["daemon_enabled"] = os.environ["VDS_LSP_DAEMON_ENABLED"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_DAEMON_IDLE_TIMEOUT"):
-        try:
-            config_data["daemon_idle_timeout"] = int(os.environ["VDS_LSP_DAEMON_IDLE_TIMEOUT"])
-        except ValueError as exc:
-            logger.warning("Invalid VDS_LSP_DAEMON_IDLE_TIMEOUT: %s", exc)
-
-    if os.environ.get("VDS_LSP_DAEMON_MAX_CLIENTS"):
-        try:
-            config_data["daemon_max_clients"] = int(os.environ["VDS_LSP_DAEMON_MAX_CLIENTS"])
-        except ValueError as exc:
-            logger.warning("Invalid VDS_LSP_DAEMON_MAX_CLIENTS: %s", exc)
-
-    if os.environ.get("VDS_LSP_DAEMON_HOT_RELOAD"):
-        config_data["hot_reload"] = os.environ["VDS_LSP_DAEMON_HOT_RELOAD"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_DIAGNOSTIC_MODE"):
-        config_data["diagnostic_mode"] = os.environ["VDS_LSP_DIAGNOSTIC_MODE"]
-
-    if os.environ.get("VDS_LSP_AUTO_FORMAT_STRINGS"):
-        config_data["auto_format_strings"] = os.environ["VDS_LSP_AUTO_FORMAT_STRINGS"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_WSL_OPTIMIZE"):
-        config_data["wsl_optimize"] = os.environ["VDS_LSP_WSL_OPTIMIZE"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-    elif os.environ.get("VDS_LSP_WSL_OPTIMIZE") is None and is_wsl2():
-        # Auto-enable WSL optimization if detected and not explicitly disabled
-        logger.info("WSL2 detected - enabling wsl_optimize for better filesystem performance")
-        config_data["wsl_optimize"] = True
-
-    # Docker mode environment variables
-    if os.environ.get("VDS_LSP_DOCKER_MODE"):
-        config_data["docker_mode"] = os.environ["VDS_LSP_DOCKER_MODE"].lower() in (
-            "true",
-            "1",
-            "yes",
-        )
-
-    if os.environ.get("VDS_LSP_DOCKER_IMAGE"):
-        config_data["docker_image"] = os.environ["VDS_LSP_DOCKER_IMAGE"]
-
-    if os.environ.get("VDS_LSP_DOCKER_WORKSPACE"):
-        config_data["docker_workspace"] = os.environ["VDS_LSP_DOCKER_WORKSPACE"]
-
-    # Type checker environment variable (only if not already set by config file)
-    # Priority: config file > env var > auto
-    if os.environ.get("VDS_LSP_TYPE_CHECKER") and "type_checker" not in config_data:
-        env_type_checker = os.environ["VDS_LSP_TYPE_CHECKER"]
-        valid_checkers = {"auto", "mypy", "basedpyright", "pyright", "pylsp"}
-        if env_type_checker in valid_checkers:
-            config_data["type_checker"] = env_type_checker
-        else:
-            logger.warning(
-                "Invalid VDS_LSP_TYPE_CHECKER value: %s (must be one of: %s), using default 'auto'",
-                env_type_checker,
-                ", ".join(sorted(valid_checkers)),
-            )
-            # Don't set config_data["type_checker"] - let default "auto" take effect
-
-    # 4. CLI overrides (highest priority)
-    if config_file:
-        config_data["config_file"] = (
-            config_file if config_file.is_absolute() else root_path / config_file
-        )
-
-    if lsp_server:
-        config_data["server_path"] = lsp_server
-
-    if "config_file" in config_data:
-        cfg_path = Path(config_data["config_file"])
-        if not cfg_path.is_absolute():
-            config_data["config_file"] = root_path / cfg_path
-
-    if "cache_dir" in config_data:
-        cache_dir = Path(config_data["cache_dir"])
-        if not cache_dir.is_absolute():
-            config_data["cache_dir"] = root_path / cache_dir
-
-    # Load basedpyright configuration context
-    base_config, base_path = _load_basedpyright_config(
-        root_path=root_path,
-        config_file=config_data.get("config_file"),
-        pyproject_data=pyproject_data,
-    )
-    config_data["basedpyright_config"] = base_config
-    config_data["basedpyright_config_path"] = base_path
-
-    if "type_checking_mode" not in config_data:
-        mode = base_config.get("typeCheckingMode")
-        if isinstance(mode, str):
-            config_data["type_checking_mode"] = mode
-
-    if "venv_path" not in config_data:
-        venv_path = base_config.get("venvPath")
-        if isinstance(venv_path, str):
-            config_data["venv_path"] = venv_path
-
-    if "venv" not in config_data:
-        venv = base_config.get("venv")
-        if isinstance(venv, str):
-            config_data["venv"] = venv
-
-    if "venv_path" not in config_data and "venv" not in config_data:
-        default_venv = root_path / ".venv"
-        if default_venv.exists():
-            config_data["venv_path"] = str(root_path)
-            config_data["venv"] = ".venv"
-
-    try:
-        config = LspConfig(**config_data)
-    except ValidationError as exc:
-        logger.exception("Invalid LSP configuration: %s", exc)
-        config = LspConfig()
-
-    if config.log_level:
-        _configure_logging(config.log_level)
-
-    return config
-
-
-def apply_text_edits(content: str, edits: list[dict[str, Any]]) -> str:
-    """Apply LSP TextEdits to content.
-
-    Args:
-        content: Original file content.
-        edits: List of LSP TextEdit dicts (range, newText).
-
-    Returns:
-        Modified content.
-    """
-
-    # Sort edits in reverse order to avoid shifting offsets
-    def get_start(edit):
-        return (edit["range"]["start"]["line"], edit["range"]["start"]["character"])
-
-    sorted_edits = sorted(edits, key=get_start, reverse=True)
-
-    lines = content.splitlines(keepends=True)
-
-    # Handle case where file doesn't end with newline but editors treat it so?
-    # For now, assume simple splitlines behavior.
-
-    for edit in sorted_edits:
-        start = edit["range"]["start"]
-        end = edit["range"]["end"]
-        new_text = edit["newText"]
-
-        start_line = start["line"]
-        start_char = start["character"]
-        end_line = end["line"]
-        end_char = end["character"]
-
-        # Safety checks
-        if start_line >= len(lines):
-            continue
-
-        # Get content before the edit range start
-        pre_text = lines[start_line][:start_char]
-
-        # Get content after the edit range end
-        post_text = lines[end_line][end_char:] if end_line < len(lines) else ""
-
-        # Construct new line(s)
-        # Note: new_text might contain newlines.
-        # If the edit spans multiple lines, we need to remove intermediate lines.
-
-        # If single line edit
-        if start_line == end_line:
-            lines[start_line] = pre_text + new_text + post_text
-        else:
-            # Multi-line edit
-            # Replace start_line with pre + new + post
-            # Remove intermediate lines
-            lines[start_line] = pre_text + new_text + post_text
-            # Delete lines from start_line + 1 to end_line
-            # Be careful with list modification index
-            del lines[start_line + 1 : end_line + 1]
-
-    return "".join(lines)
-
-
-def _uri_to_path(uri: str) -> Path:
-    if uri.startswith("file://"):
-        parsed = urlparse(uri)
-        path = unquote(parsed.path)
-        return Path(path)
-    return Path(uri)
-
-
-def extract_context(
-    file_path: Path,
-    *,
-    line: int,
-    context_lines: int,
-) -> dict[str, Any] | None:
-    if context_lines <= 0:
-        return None
-    try:
-        lines = file_path.read_text().splitlines()
-    except Exception:
-        return None
-
-    if not lines:
-        return None
-
-    line_index = max(1, min(line, len(lines)))
-    start = max(1, line_index - context_lines)
-    end = min(len(lines), line_index + context_lines)
-    snippet = "\n".join(lines[start - 1 : end])
-    line_text = lines[line_index - 1] if 0 <= line_index - 1 < len(lines) else ""
-
-    return {
-        "start_line": start,
-        "end_line": end,
-        "line": line_index,
-        "line_text": line_text,
-        "text": snippet,
-    }
-
-
-def apply_workspace_edit(
-    edit: dict[str, Any],
-    *,
-    root: Path,
-    backup_dir: Path | None = None,
-    dry_run: bool = False,
-) -> list[Path]:
-    """Apply LSP WorkspaceEdit to files.
-
-    Supports 'changes' mapping. Returns list of modified files.
-    """
-    changed_files: list[Path] = []
-
-    changes = edit.get("changes") or {}
-    document_changes = edit.get("documentChanges") or []
-    for uri, edits in changes.items():
-        file_path = _uri_to_path(uri)
-        if not file_path.is_absolute():
-            file_path = root / file_path
-
-        if not file_path.exists():
-            continue
-
-        original = file_path.read_text()
-        updated = apply_text_edits(original, edits)
-
-        if backup_dir is not None and not dry_run:
-            backup_path = backup_dir / file_path.relative_to(root)
-            backup_path.parent.mkdir(parents=True, exist_ok=True)
-            _ = backup_path.write_text(original)
-
-        if not dry_run:
-            _ = file_path.write_text(updated)
-
-        changed_files.append(file_path)
-
-    for item in document_changes:
-        text_doc = item.get("textDocument") or {}
-        uri = text_doc.get("uri")
-        edits = item.get("edits") or []
-        if not uri or not edits:
-            continue
-        file_path = _uri_to_path(uri)
-        if not file_path.is_absolute():
-            file_path = root / file_path
-        if not file_path.exists():
-            continue
-
-        original = file_path.read_text()
-        updated = apply_text_edits(original, edits)
-
-        if backup_dir is not None and not dry_run:
-            backup_path = backup_dir / file_path.relative_to(root)
-            backup_path.parent.mkdir(parents=True, exist_ok=True)
-            _ = backup_path.write_text(original)
-
-        if not dry_run:
-            _ = file_path.write_text(updated)
-
-        changed_files.append(file_path)
-
-    return changed_files
-
-
-def preview_workspace_edit(
-    edit: dict[str, Any],
-    *,
-    root: Path,
-) -> dict[Path, tuple[str, str]]:
-    """Preview WorkspaceEdit changes without writing to disk."""
-    previews: dict[Path, tuple[str, str]] = {}
-    changes = edit.get("changes") or {}
-    document_changes = edit.get("documentChanges") or []
-
-    for uri, edits in changes.items():
-        file_path = _uri_to_path(uri)
-        if not file_path.is_absolute():
-            file_path = root / file_path
-
-        if not file_path.exists():
-            continue
-
-        original = file_path.read_text()
-        updated = apply_text_edits(original, edits)
-        previews[file_path] = (original, updated)
-
-    for item in document_changes:
-        text_doc = item.get("textDocument") or {}
-        uri = text_doc.get("uri")
-        edits = item.get("edits") or []
-        if not uri or not edits:
-            continue
-        file_path = _uri_to_path(uri)
-        if not file_path.is_absolute():
-            file_path = root / file_path
-
-        if not file_path.exists():
-            continue
-
-        original = file_path.read_text()
-        updated = apply_text_edits(original, edits)
-        previews[file_path] = (original, updated)
-
-    return previews
-
-
-def build_unified_diff(
-    path: Path,
-    before: str,
-    after: str,
-) -> str:
-    """Create a unified diff string for a single file."""
-    before_lines = before.splitlines(keepends=True)
-    after_lines = after.splitlines(keepends=True)
-    diff = difflib.unified_diff(
-        before_lines,
-        after_lines,
-        fromfile=f"{path}:before",
-        tofile=f"{path}:after",
-    )
-    return "".join(diff)
-
-
-def restore_backup(backup_dir: Path, *, root: Path) -> list[Path]:
-    """Restore files from a backup directory."""
-    restored: list[Path] = []
-    for backup_file in backup_dir.rglob("*"):
-        if not backup_file.is_file():
-            continue
-        rel = backup_file.relative_to(backup_dir)
-        target = root / rel
-        target.parent.mkdir(parents=True, exist_ok=True)
-        _ = target.write_bytes(backup_file.read_bytes())
-        restored.append(target)
-    return restored
-
-
-def workspace_edit_needs_confirmation(edit: dict[str, Any]) -> bool:
-    annotations = edit.get("changeAnnotations") or {}
-    if not annotations:
-        return False
-
-    def _edit_needs_confirmation(edits: list[dict[str, Any]]) -> bool:
-        for item in edits:
-            annotation_id = item.get("annotationId")
-            if not annotation_id:
-                continue
-            annotation = annotations.get(annotation_id) or {}
-            if annotation.get("needsConfirmation"):
-                return True
-        return False
-
-    changes = edit.get("changes") or {}
-    for _uri, edits in changes.items():
-        if _edit_needs_confirmation(edits):
-            return True
-
-    document_changes = edit.get("documentChanges") or []
-    for item in document_changes:
-        edits = item.get("edits") or []
-        if _edit_needs_confirmation(edits):
-            return True
-
-    return False