@ngocsangairvds/vsaf 3.2.14 → 3.2.16

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

@@ -1,3295 +0,0 @@
-"""Core LSP routing and coordination."""
-
-import contextlib
-import logging
-import shutil
-import subprocess
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from datetime import datetime
-from pathlib import Path
-from typing import Any, cast
-
-from .aggregator import DiagnosticAggregator
-from .basedpyright_runner import BasedPyrightRunner
-from .code_actions import CodeActionExtractor
-from .lsp_client import LspClient
-from .mypy_runner import MypyRunner
-from .protocols import LspClientProtocol
-from .ruff_lsp_client import RuffLSPClient
-from .ruff_runner import RuffRunner
-from .utils import (
-    _uri_to_path,
-    apply_text_edits,
-    apply_workspace_edit,
-    build_unified_diff,
-    extract_context,
-    load_config,
-    preview_workspace_edit,
-    restore_backup,
-    workspace_edit_needs_confirmation,
-)
-from .workspace_indexer import WorkspaceIndexer
-
-logger = logging.getLogger(__name__)
-
-
-class LSPRouter:
-    """Routes LSP commands to appropriate backends."""
-
-    def __init__(
-        self,
-        root_path: Path | None = None,
-        *,
-        config_file: Path | None = None,
-        lsp_server: str | None = None,
-        force_direct: bool = False,
-    ):
-        self.root = root_path or Path.cwd()
-        self.config = load_config(self.root, config_file=config_file, lsp_server=lsp_server)
-
-        # WorkspaceIndexer expects IndexerConfig - LspConfig is compatible via Protocol
-        self.indexer = WorkspaceIndexer(
-            self.root,
-            self.config,  # pyright: ignore[reportArgumentType]
-        )
-        self.pyright = BasedPyrightRunner(self.root, self.config)
-        self.lsp: LspClientProtocol | None = None
-        self.code_actions: CodeActionExtractor | None = None
-        self.lsp_error: str | None = None
-        self.using_daemon = False
-
-        # Check if daemon mode is enabled (skip if force_direct is True, e.g., inside daemon)
-        daemon_check = use_daemon(self.root, config_file=config_file)
-        logger.info("Daemon mode check: force_direct=%s, use_daemon=%s", force_direct, daemon_check)
-        if not force_direct and daemon_check:
-            try:
-                daemon_client = get_daemon_client(self.root, config_file=config_file)
-                daemon_lsp = DaemonLspClient(self.root, self.config, daemon_client)
-                self.lsp = daemon_lsp  # pyright: ignore[reportAttributeAccessIssue]
-                self.code_actions = CodeActionExtractor(
-                    self.lsp  # pyright: ignore[reportArgumentType]
-                )
-                self.using_daemon = True
-                logger.info("Using daemon mode for LSP operations")
-            except (ConnectionError, Exception) as exc:
-                logger.warning("Daemon mode enabled but not available: %s", exc)
-                # Fall back to direct LSP client
-                self.using_daemon = False
-        elif force_direct:
-            logger.info("Daemon mode bypassed (force_direct=True)")
-        else:
-            logger.info("Daemon mode not enabled or daemon not running")
-
-        # If not using daemon, initialize direct LSP client
-        if self.lsp is None:
-            try:
-                self.lsp = LspClient(
-                    self.root,
-                    self.config,
-                    docker_mode=getattr(self.config, "docker_mode", False),
-                )
-                self.code_actions = CodeActionExtractor(self.lsp)
-            except FileNotFoundError as exc:
-                self.lsp_error = str(exc)
-                logger.warning("LSP server unavailable: %s", exc)
-            except Exception as exc:
-                self.lsp_error = str(exc)
-                logger.warning("LSP client init failed: %s", exc)
-
-        self.ruff = RuffRunner(self.root)
-        self.aggregator = DiagnosticAggregator()
-
-
-class MultiLSPRouter(LSPRouter):
-    """Routes features between BasedPyright and Ruff LSP servers."""
-
-    def __init__(
-        self,
-        root_path: Path | None = None,
-        *,
-        config_file: Path | None = None,
-        lsp_server: str | None = None,
-    ):
-        super().__init__(root_path, config_file=config_file, lsp_server=lsp_server)
-        self.ruff_lsp: RuffLSPClient | None = None
-        self.feature_map: dict[str, str] = {}
-        self._init_ruff()
-        self._init_feature_map()
-
-    def _init_ruff(self) -> None:
-        # Auto-detect Ruff LSP if not explicitly configured
-        enable_ruff = getattr(self.config, "enable_ruff_lsp", None)
-
-        # Check if explicitly disabled via config file
-        # (default False without config file should trigger auto-detection)
-        config_file = getattr(self.config, "config_file", None)
-        basedpyright_config_path = getattr(self.config, "basedpyright_config_path", None)
-        has_config = config_file is not None or basedpyright_config_path is not None
-
-        if enable_ruff is False and has_config:
-            # Explicitly disabled in config file
-            return
-        if enable_ruff is None or (enable_ruff is False and not has_config):
-            # Not explicitly configured OR using default False without config - auto-detect
-            from .ruff_lsp_client import _check_ruff_version
-
-            if not _check_ruff_version():
-                logger.debug("Ruff LSP auto-detection: ruff >= 0.5.3 not found")
-                return
-            logger.info("Ruff LSP auto-detected and enabled")
-
-        try:
-            self.ruff_lsp = RuffLSPClient(self.root, self.config)
-        except FileNotFoundError as exc:
-            logger.warning("Ruff LSP unavailable: %s", exc)
-            self.ruff_lsp = None
-
-        if self.ruff_lsp:
-            self.code_actions = CodeActionExtractor(self.ruff_lsp.lsp)
-
-    def _init_feature_map(self) -> None:
-        self.feature_map = {
-            "diagnostics": "ruff" if self.ruff_lsp else "ruff-cli",
-            "formatting": "ruff" if self.ruff_lsp else "none",
-            "code_actions": "ruff" if self.ruff_lsp else "basedpyright",
-            "organize_imports": "ruff" if self.ruff_lsp else "none",
-            "fix_all": "ruff" if self.ruff_lsp else "none",
-            "hover": "basedpyright",
-            "completion": "basedpyright",
-            "rename": "basedpyright",
-            "signature_help": "basedpyright",
-            "inlay_hints": "basedpyright",
-            "semantic_tokens": "basedpyright",
-        }
-
-    def health_check(self) -> dict[str, bool]:
-        status = {"basedpyright": self.lsp is not None, "ruff": self.ruff_lsp is not None}
-        return status
-
-
-def _build_router(
-    root: Path | None,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> LSPRouter:
-    return MultiLSPRouter(root, config_file=config_file, lsp_server=lsp_server)
-
-
-def _normalize_call_hierarchy(
-    result: list[dict[str, Any]],
-    *,
-    direction: str,
-    root: Path,
-    root_symbol: str,
-) -> list[dict[str, Any]]:
-    calls: list[dict[str, Any]] = []
-
-    for entry in result:
-        if direction == "incoming":
-            item = entry.get("from") or {}
-            from_symbol = item.get("name")
-            to_symbol = root_symbol
-        else:
-            item = entry.get("to") or {}
-            from_symbol = root_symbol
-            to_symbol = item.get("name")
-
-        if not from_symbol or not to_symbol:
-            continue
-
-        uri = item.get("uri")
-        if not uri:
-            continue
-
-        file_path = _uri_to_path(uri)
-        external = False
-        if file_path.is_absolute():
-            try:
-                file_path = file_path.relative_to(root)
-            except ValueError:
-                external = True
-
-        ranges = entry.get("fromRanges") or []
-        range_info = ranges[0] if ranges else item.get("range") or item.get("selectionRange") or {}
-        start = range_info.get("start", {})
-        end = range_info.get("end", {})
-        start_line = start.get("line", 0) + 1
-        start_col = start.get("character", 0) + 1
-        end_line = end.get("line", start.get("line", 0)) + 1
-        end_col = end.get("character", start.get("character", 0)) + 1
-
-        calls.append(
-            {
-                "from_symbol": from_symbol,
-                "to_symbol": to_symbol,
-                "location": {
-                    "file": file_path.as_posix(),
-                    "line": start_line,
-                    "column": start_col,
-                    "end_line": end_line,
-                    "end_column": end_col,
-                },
-                "depth": 1,
-                "relation": "direct",
-                "path": [from_symbol, to_symbol],
-                "external": external,
-            },
-        )
-
-    return calls
-
-
-def _call_hierarchy(
-    router: LSPRouter,
-    symbol: str,
-    *,
-    direction: str,
-) -> list[dict[str, Any]] | None:
-    if not router.lsp:
-        return None
-
-    # Type narrowing: after the check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    matches = router.indexer.find_symbols(symbol)
-    if not matches:
-        return None
-
-    location = matches[0]["location"]
-    # Ensure location is a dict-like object with required keys
-    if not isinstance(location, dict):
-        return None
-    # Cast to proper dict type for indexing - location values are union types from indexer
-    loc = cast(dict[str, Any], location)
-    file_path = router.root / loc["file"]
-    uri: str | None = None
-
-    try:
-        uri = lsp.open_document(file_path)
-        params = {
-            "textDocument": {"uri": uri},
-            "position": {
-                "line": loc["line"] - 1,
-                "character": loc["column"] - 1,
-            },
-        }
-        items = lsp.request("textDocument/prepareCallHierarchy", params)
-        if not items:
-            return None
-        item = items[0]
-        method = (
-            "callHierarchy/incomingCalls"
-            if direction == "incoming"
-            else "callHierarchy/outgoingCalls"
-        )
-        result = lsp.request(method, {"item": item})
-        if not result:
-            return []
-        return _normalize_call_hierarchy(
-            result, direction=direction, root=router.root, root_symbol=symbol
-        )
-    except Exception as exc:
-        logger.debug("Call hierarchy via LSP failed: %s", exc)
-        return None
-    finally:
-        if uri and lsp:
-            lsp.close_document(uri)
-
-
-def find_symbols(
-    path: Path,
-    query: str,
-    kind: str | None,
-    match: str = "contains",
-    limit: int | None = 50,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> list[dict[str, Any]]:
-    """Find symbols in workspace using LSP-first approach with AST fallback."""
-    router = _build_router(path, config_file=config_file, lsp_server=lsp_server)
-
-    # Try LSP first
-    if router.lsp:
-        try:
-            result = router.lsp.request("workspace/symbol", {"query": query})
-            if result:
-                symbols: list[dict[str, Any]] = []
-                for item in result:
-                    # Convert LSP SymbolInformation to our format
-                    uri = item.get("uri")
-                    if not uri:
-                        continue
-
-                    file_path = _uri_to_path(uri)
-                    if not file_path.is_absolute():
-                        file_path = router.root / file_path
-
-                    # Convert to relative path if within workspace
-                    with contextlib.suppress(ValueError):
-                        file_path = file_path.relative_to(router.root)
-
-                    # Convert LSP kind to our SymbolKind
-                    lsp_kind = item.get("kind", 0)
-                    kind_name = _lsp_symbol_kind_to_name(lsp_kind)
-
-                    # Apply kind filter if specified
-                    if kind and kind_name.lower() != kind.lower():
-                        continue
-
-                    # Get location info
-                    location = item.get("location") or {}
-                    range_info = location.get("range") or {}
-                    start = range_info.get("start", {})
-                    end = range_info.get("end", {})
-
-                    symbol = {
-                        "name": item.get("name", ""),
-                        "kind": kind_name,
-                        "location": {
-                            "file": str(file_path),
-                            "line": start.get("line", 0) + 1,
-                            "column": start.get("character", 0) + 1,
-                            "end_line": end.get("line", start.get("line", 0)) + 1,
-                            "end_column": end.get("character", start.get("character", 0)) + 1,
-                        },
-                        "container_name": item.get("containerName"),
-                        "source": "lsp",
-                    }
-                    symbols.append(symbol)
-
-                if symbols and limit is not None and limit > 0:
-                    symbols = symbols[:limit]
-
-                if symbols:
-                    logger.debug("Found %d symbols via LSP", len(symbols))
-                    return symbols
-        except Exception as exc:
-            logger.debug("LSP workspace/symbol failed: %s", exc)
-
-    # Fallback to AST
-    logger.debug("Falling back to AST-based symbol search")
-    ast_symbols = router.indexer.find_symbols(query, kind, match=match, limit=limit)
-
-    # Mark with source
-    for symbol in ast_symbols:
-        symbol["source"] = "ast"
-
-    return ast_symbols
-
-
-def check_types(
-    paths: list[Path],
-    mode: str,
-    fix: bool,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    type_checker: str | None = None,
-) -> dict[str, Any]:
-    """Run type checking using detected or specified type checker.
-
-    Args:
-        paths: List of paths to type check
-        mode: Type checking mode (basic, standard, strict)
-        fix: Whether to apply auto-fixes
-        config_file: Optional config file path
-        lsp_server: Optional LSP server path
-        type_checker: Optional explicit type checker ("mypy", "basedpyright", etc.)
-
-    Returns:
-        Dictionary with type check results
-    """
-    # Determine which type checker to use
-    if type_checker and type_checker != "auto":
-        checker = type_checker
-    else:
-        # Auto-detect using ProjectDetector
-        root = paths[0] if paths else Path.cwd()
-        from .models.project_detector import ProjectDetector
-
-        detector = ProjectDetector(root)
-        tools = detector.detect_all()
-        checker = tools.type_checker
-
-    logger.debug("Using type checker: %s", checker)
-
-    # Route to appropriate runner
-    if checker == "mypy":
-        runner = MypyRunner()
-        diagnostics = runner.check_types(paths, mode=mode)
-        return {
-            "type_checker": "mypy",
-            "diagnostics": diagnostics,
-            "summary": f"Checked {len(paths)} path(s) with mypy",
-        }
-    else:  # basedpyright, pyright, pylsp - all use BasedPyrightRunner
-        router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-        result = router.pyright.check_types([str(p) for p in paths], mode, fix)
-        result["type_checker"] = checker
-        return result
-
-
-def go_to_definition(
-    symbol: str,
-    file: str | None,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Go to symbol definition.
-
-    If 'file' is provided (format "path/to/file:line:col"), we try to use LSP.
-    Otherwise, or if LSP fails, we fall back to AST symbol search by name.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-
-    # If location is provided, try LSP first
-    if file and ":" in file and router.lsp:
-        uri: str | None = None
-        try:
-            file_path_str, line_str, col_str = file.split(":")
-            line = int(line_str)
-            col = int(col_str)
-            file_path = Path(file_path_str)
-            if not file_path.is_absolute():
-                file_path = router.root / file_path
-
-            uri = router.lsp.open_document(file_path)
-            params = {
-                "textDocument": {"uri": uri},
-                "position": {"line": line - 1, "character": col - 1},
-            }
-
-            result = router.lsp.request("textDocument/definition", params)
-            if result:
-                locations = result if isinstance(result, list) else [result]
-                return {"source": "lsp", "locations": locations}
-        except Exception as exc:
-            logger.debug("LSP definition lookup failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback: AST Symbol Search
-    # If we have a file/line/col but LSP failed, find the symbol name at that position first
-    if file and ":" in file:
-        file_path_str, line_str, col_str = file.split(":")
-        file_path = Path(file_path_str)
-        if not file_path.is_absolute():
-            file_path = router.root / file_path
-        symbol_at_pos = router.indexer.get_symbol_at_position(
-            file_path, int(line_str), int(col_str)
-        )
-        if symbol_at_pos:
-            symbol = symbol_at_pos
-
-    # Search by name
-    symbols = router.indexer.find_symbols(symbol)
-    return {"source": "ast", "locations": symbols}
-
-
-def go_to_implementation(
-    file: str,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Go to implementation(s) of a symbol at a location.
-
-    Takes file path with line and column (format "path/to/file:line:col").
-    Uses BasedPyright LSP client to call textDocument/implementation.
-    Falls back to AST-based search if LSP unavailable.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-
-    # Validate location format
-    if ":" not in file:
-        return {
-            "source": "error",
-            "locations": [],
-            "message": "Location must be in format file:line:col",
-        }
-
-    # If location is provided, try LSP first
-    if file and ":" in file and router.lsp:
-        uri: str | None = None
-        try:
-            file_path_str, line_str, col_str = file.split(":")
-            line = int(line_str)
-            col = int(col_str)
-            file_path = Path(file_path_str)
-            if not file_path.is_absolute():
-                file_path = router.root / file_path
-
-            uri = router.lsp.open_document(file_path)
-            params = {
-                "textDocument": {"uri": uri},
-                "position": {"line": line - 1, "character": col - 1},
-            }
-
-            result = router.lsp.request("textDocument/implementation", params)
-            if result:
-                locations = result if isinstance(result, list) else [result]
-                return {"source": "lsp", "locations": locations}
-        except Exception as exc:
-            logger.debug("LSP implementation lookup failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback: AST-based search
-    # Find the symbol name at the position and search for implementations
-    file_path_str, line_str, col_str = file.split(":")
-    file_path = Path(file_path_str)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    symbol_at_pos = router.indexer.get_symbol_at_position(file_path, int(line_str), int(col_str))
-    if symbol_at_pos:
-        # Search for the symbol to find its implementations
-        symbols = router.indexer.find_symbols(symbol_at_pos)
-        return {
-            "source": "ast",
-            "locations": symbols,
-            "message": "LSP unavailable, showing symbol definitions",
-        }
-
-    return {"source": "ast", "locations": [], "message": "No symbol found at location"}
-
-
-def get_callers(
-    symbol: str,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    max_depth: int | None = None,
-) -> dict[str, Any]:
-    """Get callers of a symbol."""
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    depth_limit = 1 if max_depth is None else max(max_depth, 1)
-    stats = {"count": 0, "max_depth": 0}
-    if depth_limit == 1:
-        lsp_result = _call_hierarchy(router, symbol, direction="incoming")
-        if lsp_result is not None:
-            if lsp_result:
-                stats["count"] = len(lsp_result)  # type: ignore[assignment]
-                stats["max_depth"] = max(call.get("depth", 1) for call in lsp_result)  # type: ignore[assignment]
-            return {"source": "lsp", "callers": lsp_result, "stats": stats}
-    else:
-        logger.debug("Using AST call hierarchy for max_depth=%s", depth_limit)
-    callers = router.indexer.get_callers(symbol, max_depth=depth_limit)
-    if callers:
-        stats["count"] = len(callers)
-        stats["max_depth"] = cast(int, max((call.get("depth", 1) or 1) for call in callers))
-    return {"source": "ast", "callers": callers, "stats": stats}
-
-
-def get_callees(
-    symbol: str,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    max_depth: int | None = None,
-) -> dict[str, Any]:
-    """Get callees of a symbol."""
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    depth_limit = 1 if max_depth is None else max(max_depth, 1)
-    stats = {"count": 0, "max_depth": 0}
-    if depth_limit == 1:
-        lsp_result = _call_hierarchy(router, symbol, direction="outgoing")
-        if lsp_result is not None:
-            if lsp_result:
-                stats["count"] = len(lsp_result)  # type: ignore[assignment]
-                stats["max_depth"] = max(call.get("depth", 1) for call in lsp_result)  # type: ignore[assignment]
-            return {"source": "lsp", "callees": lsp_result, "stats": stats}
-    else:
-        logger.debug("Using AST call hierarchy for max_depth=%s", depth_limit)
-    callees = router.indexer.get_callees(symbol, max_depth=depth_limit)
-    if callees:
-        stats["count"] = len(callees)
-        stats["max_depth"] = cast(int, max((call.get("depth", 1) or 1) for call in callees))
-    return {"source": "ast", "callees": callees, "stats": stats}
-
-
-def find_references(
-    symbol: str,
-    file: str | None,
-    *,
-    context_lines: int = 0,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Find references to a symbol.
-
-    If 'file' is provided (format "path/to/file:line:col"), we try to use LSP.
-    Otherwise, we fall back to AST text search.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-
-    # Try LSP first if location provided
-    if file and ":" in file and router.lsp:
-        uri: str | None = None
-        try:
-            file_path_str, line_str, col_str = file.split(":")
-            line = int(line_str)
-            col = int(col_str)
-            file_path = Path(file_path_str)
-            if not file_path.is_absolute():
-                file_path = router.root / file_path
-
-            uri = router.lsp.open_document(file_path)
-            params = {
-                "textDocument": {"uri": uri},
-                "position": {"line": line - 1, "character": col - 1},
-                "context": {"includeDeclaration": True},
-            }
-            result = router.lsp.request("textDocument/references", params)
-            if result:
-                refs: list[dict[str, Any]] = []
-                for ref in result:
-                    ref_item = dict(ref)
-                    uri_val = ref_item.get("uri")
-                    if uri_val:
-                        file_path = _uri_to_path(uri_val)
-                        if not file_path.is_absolute():
-                            file_path = router.root / file_path
-                        start = ref_item.get("range", {}).get("start", {})
-                        line = start.get("line", 0) + 1
-                        context = extract_context(file_path, line=line, context_lines=context_lines)
-                        if context:
-                            ref_item["context"] = context
-                    ref_item.setdefault("category", "reference")
-                    refs.append(ref_item)
-                return {"source": "lsp", "references": refs}
-        except Exception as exc:
-            logger.debug("LSP references lookup failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback to AST
-    # If file provided, try to resolve symbol name at position first
-    if file and ":" in file:
-        file_path_str, line_str, col_str = file.split(":")
-        file_path = Path(file_path_str)
-        if not file_path.is_absolute():
-            file_path = router.root / file_path
-        symbol_at_pos = router.indexer.get_symbol_at_position(
-            file_path, int(line_str), int(col_str)
-        )
-        if symbol_at_pos:
-            symbol = symbol_at_pos
-
-    refs = router.indexer.find_references(symbol, context_lines=context_lines)
-    return {"source": "ast", "references": refs}
-
-
-def get_document_symbols(
-    file: Path,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get document symbols.
-
-    Try LSP first, fallback to AST.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-
-    # Try LSP first
-    if router.lsp:
-        uri: str | None = None
-        try:
-            file_path = file if file.is_absolute() else router.root / file
-            uri = router.lsp.open_document(file_path)
-            params = {"textDocument": {"uri": uri}}
-            result = router.lsp.request("textDocument/documentSymbol", params)
-            if result:
-                return {"source": "lsp", "symbols": result}
-        except Exception as exc:
-            logger.debug("LSP document symbols failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback to AST
-    symbols = router.indexer.get_document_symbols_tree(router.root / file)
-    return {"source": "ast", "symbols": symbols}
-
-
-def get_diagnostics(
-    paths: list[Path],
-    include_warnings: bool = True,
-    include_fixable: bool = False,
-    max_fixable: int | None = None,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get diagnostics for paths (basedpyright + ruff)."""
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    basedpyright = router.pyright.check_types([str(p) for p in paths])
-    ruff_lsp = None
-    ruff_cli = None
-    notebook_paths = [p for p in paths if p.suffix == ".ipynb"]
-    non_notebook_paths = [p for p in paths if p.suffix != ".ipynb"]
-    if isinstance(router, MultiLSPRouter) and router.ruff_lsp:
-        if non_notebook_paths:
-            ruff_lsp = router.ruff_lsp.get_diagnostics(non_notebook_paths)
-        if notebook_paths:
-            ruff_cli = router.ruff.check([str(p) for p in notebook_paths])
-    else:
-        ruff_cli = router.ruff.check([str(p) for p in paths])
-    payload = router.aggregator.aggregate(
-        basedpyright,
-        ruff_cli,
-        ruff_lsp=ruff_lsp,
-        include_warnings=include_warnings,
-    )
-
-    fixable_count = 0  # Initialize to avoid "possibly unbound" error
-    # Convert read-only TypedDict to mutable dict for modification
-    result: dict[str, Any] = dict(payload)  # pyright: ignore[reportAssignmentType]
-    diagnostics = [dict(d) for d in result.get("diagnostics", [])]
-    if include_fixable:
-        if router.code_actions and router.lsp:
-            for diag in diagnostics:
-                if max_fixable is not None and fixable_count >= max_fixable:
-                    diag["fixable"] = None
-                    continue
-                file_path = diag.get("file")
-                if not file_path:
-                    diag["fixable"] = False
-                    continue
-                path = Path(file_path)
-                if not path.is_absolute():
-                    path = router.root / path
-                range_start = diag.get("range", {}).get("start", {})
-                line = range_start.get("line", 0) + 1
-                col = range_start.get("character", 0) + 1
-                actions = router.code_actions.get_code_actions(path, line, col, diagnostics=[diag])
-                is_fixable = bool(actions)
-                diag["fixable"] = is_fixable
-                diag["actions_available"] = len(actions)
-                if is_fixable:
-                    fixable_count += 1
-        else:
-            for diag in diagnostics:
-                diag["fixable"] = None
-    result["diagnostics"] = diagnostics
-    result["fixable_count"] = fixable_count
-
-    return result
-
-
-def fix_errors(
-    paths: list[Path],
-    *,
-    apply: bool = False,
-    max_actions: int | None = None,
-    allow_kinds: list[str] | None = None,
-    confirm_annotations: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Attempt to fix errors in specified paths.
-
-    This is a complex operation:
-    1. Get diagnostics
-    2. Request code actions for errors
-    3. Apply available quickfixes
-
-    For now, we implement a simplified version that can be expanded.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not router.code_actions or not router.lsp:
-        return {
-            "fixed_count": 0,
-            "actions_available": 0,
-            "message": "No LSP server available for code actions.",
-            "error": router.lsp_error,
-        }
-
-    diagnostics_data = router.pyright.check_types([str(p) for p in paths])
-    diagnostics = diagnostics_data.get("diagnostics") or []
-
-    if not diagnostics:
-        return {"fixed_count": 0, "actions_available": 0, "message": "No diagnostics found."}
-
-    actions_available = 0
-    actions_applied = 0
-    actions_considered = 0
-    skipped_needs_confirmation = 0
-    previews: list[dict[str, Any]] = []
-    patch_chunks: list[str] = []
-    backup_dir: Path | None = None
-
-    if apply:
-        stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-        backup_dir = router.root / ".vds-lsp" / "backups" / stamp
-
-    for diag in diagnostics:
-        file_path = diag.get("file")
-        if not file_path:
-            continue
-        file_path = Path(file_path)
-        if not file_path.is_absolute():
-            file_path = router.root / file_path
-
-        range_start = diag.get("range", {}).get("start", {})
-        line = range_start.get("line", 0) + 1
-        col = range_start.get("character", 0) + 1
-
-        actions = router.code_actions.get_code_actions(file_path, line, col, diagnostics=[diag])
-        actions_available += len(actions)
-
-        for action in actions:
-            if max_actions is not None and actions_applied >= max_actions:
-                break
-            if action.get("disabled"):
-                continue
-
-            kind = (action.get("kind") or "").lower()
-            category = (action.get("category") or "").lower()
-            if allow_kinds:
-                if not any(
-                    kind.startswith(k.lower()) or category == k.lower() for k in allow_kinds
-                ):
-                    continue
-            elif not (category == "quickfix" or kind.startswith("quickfix")):
-                continue
-            actions_considered += 1
-
-            resolved = action
-            if "edit" not in action and "data" in action:
-                try:
-                    resolved = router.lsp.request("codeAction/resolve", action)
-                except Exception as exc:
-                    logger.debug("Failed to resolve code action: %s", exc)
-
-            edit = resolved.get("edit") or action.get("edit")
-            command = resolved.get("command") or action.get("command")
-
-            if edit:
-                needs_confirmation = workspace_edit_needs_confirmation(edit)
-                if apply and needs_confirmation and not confirm_annotations:
-                    skipped_needs_confirmation += 1
-                    previews.append(
-                        {
-                            "file": str(file_path),
-                            "title": action.get("title", "Unnamed action"),
-                            "needs_confirmation": True,
-                        },
-                    )
-                    continue
-                if not apply:
-                    preview_map = preview_workspace_edit(edit, root=router.root)
-                    for path, (before, after) in preview_map.items():
-                        patch_chunks.append(build_unified_diff(path, before, after))
-                        previews.append(
-                            {
-                                "file": str(path),
-                                "before": before,
-                                "after": after,
-                                "title": action.get("title", "Unnamed action"),
-                                "needs_confirmation": needs_confirmation,
-                            },
-                        )
-                else:
-                    changed = apply_workspace_edit(
-                        edit,
-                        root=router.root,
-                        backup_dir=backup_dir,
-                        dry_run=False,
-                    )
-                    if changed:
-                        actions_applied += 1
-                continue
-
-            if command:
-                if not apply:
-                    previews.append(
-                        {
-                            "file": str(file_path),
-                            "command": command,
-                            "title": action.get("title", "Unnamed action"),
-                        },
-                    )
-                    continue
-
-                try:
-                    payload = command if isinstance(command, dict) else {"command": command}
-                    router.lsp.request("workspace/executeCommand", payload)
-                    actions_applied += 1
-                except Exception as exc:
-                    logger.debug("Failed to execute code action command: %s", exc)
-
-    if apply:
-        return {
-            "fixed_count": actions_applied,
-            "actions_available": actions_available,
-            "actions_considered": actions_considered,
-            "skipped_needs_confirmation": skipped_needs_confirmation,
-            "backup_dir": str(backup_dir) if backup_dir else None,
-            "message": "Applied code actions.",
-        }
-
-    return {
-        "fixed_count": 0,
-        "actions_available": actions_available,
-        "actions_considered": actions_considered,
-        "skipped_needs_confirmation": skipped_needs_confirmation,
-        "previews": previews,
-        "patch": "".join(patch_chunks),
-        "message": "Use --apply to apply available code actions.",
-    }
-
-
-def rollback_fixes(
-    backup_dir: Path,
-    *,
-    root: Path | None = None,
-) -> dict[str, Any]:
-    """Restore files from a backup directory created by fix-errors."""
-    resolved_root = root or Path.cwd()
-
-    if not backup_dir.exists():
-        return {"restored": 0, "message": "Backup directory does not exist."}
-
-    restored = restore_backup(backup_dir, root=resolved_root)
-    return {
-        "restored": len(restored),
-        "files": [str(path) for path in restored],
-        "message": "Restored files from backup.",
-    }
-
-
-def get_code_actions(
-    file: str,
-    line: int,
-    col: int,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> list[dict[str, Any]]:
-    """Get code actions for location."""
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not router.code_actions:
-        return []
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-    return router.code_actions.get_code_actions(file_path, line, col)
-
-
-def _require_language_services(router: LSPRouter) -> dict[str, Any] | None:
-    if not getattr(router.config, "enable_language_services", True):
-        return {"message": "Language services are disabled by configuration.", "result": None}
-    if not router.lsp:
-        return {"message": "BasedPyright LSP is unavailable.", "result": None}
-    return None
-
-
-def _format_operator_hover(hover_result: dict[str, Any] | None) -> dict[str, Any]:
-    """Format operator hover result to highlight dunder methods.
-
-    BasedPyright provides hover information for operators that includes
-    the corresponding dunder method (e.g., `+` -> `__add__`).
-    This function enhances the output to make this clearer.
-
-    Args:
-        hover_result: The raw LSP hover result
-
-    Returns:
-        Enhanced hover result with operator metadata
-    """
-    if not hover_result:
-        return {"is_operator": False, "result": None}
-
-    contents = hover_result.get("contents")
-    if not contents:
-        return {"is_operator": False, "result": hover_result}
-
-    # Extract the hover text
-    hover_text = ""
-    if isinstance(contents, str):
-        hover_text = contents
-    elif isinstance(contents, list):
-        # Handle MarkedString format
-        for item in contents:
-            if isinstance(item, str):
-                hover_text += item
-            elif isinstance(item, dict):
-                hover_text += item.get("value", "")
-
-    # Check if this looks like an operator hover (contains dunder method references)
-    operator_dunder_methods = [
-        "__add__",
-        "__sub__",
-        "__mul__",
-        "__truediv__",
-        "__floordiv__",
-        "__mod__",
-        "__pow__",
-        "__eq__",
-        "__ne__",
-        "__lt__",
-        "__le__",
-        "__gt__",
-        "__ge__",
-        "__contains__",
-        "__getitem__",
-        "__setitem__",
-        "__and__",
-        "__or__",
-        "__xor__",
-        "__lshift__",
-        "__rshift__",
-        "__iadd__",
-        "__isub__",
-        "__imul__",
-        "__itruediv__",
-        "__ifloordiv__",
-    ]
-
-    is_operator = any(
-        f"__{method}" in hover_text or method in hover_text for method in operator_dunder_methods
-    )
-
-    if is_operator:
-        # Enhance the result with operator metadata
-        return {
-            "is_operator": True,
-            "result": hover_result,
-            "operator_info": {
-                "description": "Operator hover - shows dunder method implementation",
-                "note": "Use 'goto' command to jump to the dunder method definition",
-            },
-        }
-
-    return {"is_operator": False, "result": hover_result}
-
-
-def hover(
-    file: Path,
-    line: int,
-    col: int,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get hover information at a location.
-
-    Supports:
-    - Symbol documentation (functions, classes, variables)
-    - Operator hover (shows dunder method implementation like __add__, __mul__)
-
-    BasedPyright provides hover for operators like +, *, //, etc., showing
-    the corresponding dunder method and its documentation.
-
-    Args:
-        file: Path to the file
-        line: Line number (1-indexed)
-        col: Column number (1-indexed)
-        config_file: Optional path to pyright config
-        lsp_server: Optional LSP server override
-
-    Returns:
-        Dict with hover result. Includes 'is_operator' key for operator hovers.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    # Use longer timeout for first-time requests (30 seconds)
-    # BasedPyright needs significant time to process newly opened files
-    result = lsp.request_with_timeout(
-        "textDocument/hover",
-        {"textDocument": {"uri": uri}, "position": {"line": line - 1, "character": col - 1}},
-        timeout=30.0,
-    )
-    # In daemon mode, keep documents open to avoid re-processing overhead
-    # Subsequent requests will be fast since the file is already loaded
-    if not router.using_daemon:
-        lsp.close_document(uri)
-
-    # Enhance operator hover results
-    formatted = _format_operator_hover(result)
-    response = {"message": "OK", "result": formatted["result"]}
-    if formatted["is_operator"]:
-        response["is_operator"] = True
-        response["operator_info"] = formatted.get("operator_info")
-    return response
-
-
-def completion(
-    file: Path,
-    line: int,
-    col: int,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    # Use shorter timeout for language service (5 seconds)
-    result = lsp.request_with_timeout(
-        "textDocument/completion",
-        {"textDocument": {"uri": uri}, "position": {"line": line - 1, "character": col - 1}},
-        timeout=5.0,
-    )
-    lsp.close_document(uri)
-    return {"message": "OK", "result": result}
-
-
-def rename_symbol(
-    file: Path,
-    line: int,
-    col: int,
-    new_name: str,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    edit = lsp.request(
-        "textDocument/rename",
-        {
-            "textDocument": {"uri": uri},
-            "position": {"line": line - 1, "character": col - 1},
-            "newName": new_name,
-        },
-    )
-    lsp.close_document(uri)
-    if not edit:
-        return {"message": "No rename edits available.", "applied": False}
-    if not apply:
-        preview_map = preview_workspace_edit(edit, root=router.root)
-        return {
-            "message": "Use --apply to apply rename.",
-            "applied": False,
-            "previews": [
-                {"file": str(path), "before": before, "after": after}
-                for path, (before, after) in preview_map.items()
-            ],
-        }
-    changed = apply_workspace_edit(edit, root=router.root, dry_run=False)
-    return {"message": "Rename applied.", "applied": True, "files": [str(p) for p in changed]}
-
-
-def signature_help(
-    file: Path,
-    line: int,
-    col: int,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    # Use shorter timeout for language service (5 seconds)
-    result = lsp.request_with_timeout(
-        "textDocument/signatureHelp",
-        {"textDocument": {"uri": uri}, "position": {"line": line - 1, "character": col - 1}},
-        timeout=5.0,
-    )
-    lsp.close_document(uri)
-    return {"message": "OK", "result": result}
-
-
-def inlay_hints(
-    file: Path,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    inlay_return_types: bool = True,
-    inlay_variable_types: bool = True,
-    inlay_function_parameters: bool = True,
-    inlay_generic_types: bool = True,
-    inlay_parameter_names_matching: bool = False,
-) -> dict[str, Any]:
-    """Get inlay hints from BasedPyright LSP.
-
-    Args:
-        file: Path to the file to analyze
-        config_file: Optional path to pyright config file
-        lsp_server: Optional LSP server command override
-        inlay_return_types: Enable function return type hints
-        inlay_variable_types: Enable variable type hints
-        inlay_function_parameters: Enable function parameter name hints
-        inlay_generic_types: Enable generic type hints
-        inlay_parameter_names_matching: Enable hints when param name matches arg name
-
-    Returns:
-        Dictionary with inlay hints results
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    lsp.configure_inlay_hints(
-        variable_types=inlay_variable_types,
-        function_return_types=inlay_return_types,
-        call_argument_names=inlay_function_parameters,
-        generic_types=inlay_generic_types,
-        call_argument_names_matching=inlay_parameter_names_matching,
-    )
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    content = file_path.read_text()
-    lines = content.splitlines()
-    end_line = max(len(lines) - 1, 0)
-    end_col = len(lines[end_line]) if lines else 0
-    result = lsp.request(
-        "textDocument/inlayHint",
-        {
-            "textDocument": {"uri": uri},
-            "range": {
-                "start": {"line": 0, "character": 0},
-                "end": {"line": end_line, "character": end_col},
-            },
-        },
-    )
-    lsp.close_document(uri)
-    return {"message": "OK", "result": result}
-
-
-def semantic_tokens(
-    file: Path,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    guard = _require_language_services(router)
-    if guard:
-        return guard
-
-    # Type narrowing: after the guard check, lsp is guaranteed to be not None
-    lsp = router.lsp
-    assert lsp is not None  # Type narrowing for mypy/pyright
-
-    file_path = file if file.is_absolute() else router.root / file
-    uri = lsp.open_document(file_path)
-    result = lsp.request("textDocument/semanticTokens/full", {"textDocument": {"uri": uri}})
-    lsp.close_document(uri)
-    return {"message": "OK", "result": result}
-
-
-def lsp_health(
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if isinstance(router, MultiLSPRouter):
-        return {"status": router.health_check()}
-    return {"status": {"basedpyright": router.lsp is not None}}
-
-
-def apply_code_action(
-    file: str,
-    line: int,
-    col: int,
-    index: int,
-    *,
-    apply: bool = False,
-    confirm_annotations: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Preview or apply a single code action at a location."""
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not router.code_actions or not router.lsp:
-        return {
-            "applied": False,
-            "message": "No LSP server available for code actions.",
-            "error": router.lsp_error,
-        }
-
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    actions = router.code_actions.get_code_actions(file_path, line, col)
-    if not actions:
-        return {"applied": False, "message": "No code actions available."}
-
-    if index < 1 or index > len(actions):
-        return {
-            "applied": False,
-            "message": f"Invalid index {index}. Available actions: 1..{len(actions)}.",
-        }
-
-    action = actions[index - 1]
-    if action.get("disabled"):
-        return {"applied": False, "message": "Selected action is disabled by the server."}
-
-    resolved = action
-    if "edit" not in action and "data" in action:
-        try:
-            resolved = router.lsp.request("codeAction/resolve", action)
-        except Exception as exc:
-            logger.debug("Failed to resolve code action: %s", exc)
-
-    edit = resolved.get("edit") or action.get("edit")
-    command = resolved.get("command") or action.get("command")
-
-    if edit:
-        needs_confirmation = workspace_edit_needs_confirmation(edit)
-        if apply and needs_confirmation and not confirm_annotations:
-            return {
-                "applied": False,
-                "needs_confirmation": True,
-                "message": "Action requires confirmation via change annotations.",
-            }
-
-        if not apply:
-            preview_map = preview_workspace_edit(edit, root=router.root)
-            previews: list[dict[str, Any]] = []
-            patch_chunks: list[str] = []
-            for path, (before, after) in preview_map.items():
-                patch_chunks.append(build_unified_diff(path, before, after))
-                previews.append(
-                    {
-                        "file": str(path),
-                        "before": before,
-                        "after": after,
-                        "title": action.get("title", "Unnamed action"),
-                        "needs_confirmation": needs_confirmation,
-                    },
-                )
-            return {
-                "applied": False,
-                "previews": previews,
-                "patch": "".join(patch_chunks),
-                "message": "Use --apply to apply the selected action.",
-            }
-
-        stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-        backup_dir = router.root / ".vds-lsp" / "backups" / stamp
-        changed = apply_workspace_edit(edit, root=router.root, backup_dir=backup_dir, dry_run=False)
-        return {
-            "applied": bool(changed),
-            "backup_dir": str(backup_dir),
-            "message": "Applied code action." if changed else "No changes applied.",
-        }
-
-    if command:
-        if not apply:
-            return {
-                "applied": False,
-                "command": command,
-                "message": "Use --apply to execute the selected action.",
-            }
-        try:
-            payload = command if isinstance(command, dict) else {"command": command}
-            router.lsp.request("workspace/executeCommand", payload)
-            return {"applied": True, "message": "Executed code action command."}
-        except Exception as exc:
-            logger.debug("Failed to execute code action command: %s", exc)
-            return {"applied": False, "message": "Failed to execute code action command."}
-
-    return {"applied": False, "message": "Selected action has no edit or command."}
-
-
-def _action_is_unsafe(action: dict[str, Any]) -> bool:
-    data = action.get("data")
-    if isinstance(data, dict) and data.get("isUnsafe"):
-        return True
-    title = str(action.get("title", "")).lower()
-    return "unsafe" in title
-
-
-def _apply_code_action_by_kind(
-    router: LSPRouter,
-    file_path: Path,
-    kind_prefix: str,
-    *,
-    apply: bool,
-    allow_unsafe: bool,
-) -> dict[str, Any]:
-    if not router.code_actions or not router.lsp:
-        return {"applied": False, "message": "No LSP server available for code actions."}
-    only = [kind_prefix]
-    if kind_prefix == "source.fixAll":
-        only.append("source.fixAll.ruff")
-    actions = router.code_actions.get_code_actions(file_path, 1, 1, only=only)
-    selected = None
-    for action in actions:
-        kind = (action.get("kind") or "").lower()
-        if kind.startswith(kind_prefix.lower()):
-            if not allow_unsafe and _action_is_unsafe(action):
-                continue
-            selected = action
-            break
-    if not selected:
-        return {"applied": False, "message": f"No code action found for kind {kind_prefix}."}
-
-    resolved = selected
-    if "edit" not in selected and "data" in selected:
-        try:
-            resolved = router.lsp.request("codeAction/resolve", selected)
-        except Exception as exc:
-            logger.debug("Failed to resolve code action: %s", exc)
-
-    edit = resolved.get("edit") or selected.get("edit")
-    command = resolved.get("command") or selected.get("command")
-
-    if not apply:
-        if edit:
-            preview_map = preview_workspace_edit(edit, root=router.root)
-            return {
-                "applied": False,
-                "previews": [
-                    {"file": str(path), "before": before, "after": after}
-                    for path, (before, after) in preview_map.items()
-                ],
-                "message": "Use --apply to apply the selected action.",
-            }
-        if command:
-            return {
-                "applied": False,
-                "command": command,
-                "message": "Use --apply to execute the selected action.",
-            }
-
-    if edit:
-        changed = apply_workspace_edit(edit, root=router.root, dry_run=False)
-        return {
-            "applied": bool(changed),
-            "files": [str(path) for path in changed],
-            "message": "Applied code action." if changed else "No changes applied.",
-        }
-    if command:
-        payload = command if isinstance(command, dict) else {"command": command}
-        router.lsp.request("workspace/executeCommand", payload)
-        return {"applied": True, "message": "Executed code action command."}
-
-    return {"applied": False, "message": "Selected action has no edit or command."}
-
-
-def format_document(
-    file: Path,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not isinstance(router, MultiLSPRouter) or not router.ruff_lsp:
-        return {"applied": False, "message": "Ruff LSP is not enabled or available."}
-    file_path = file if file.is_absolute() else router.root / file
-    uri = router.ruff_lsp.open_document(file_path)
-    edits = router.ruff_lsp.request(
-        "textDocument/formatting",
-        {"textDocument": {"uri": uri}, "options": {"tabSize": 4, "insertSpaces": True}},
-    )
-    router.ruff_lsp.close_document(uri)
-    if not edits:
-        return {"applied": False, "message": "No formatting changes available."}
-    before = file_path.read_text()
-    after = apply_text_edits(before, edits)
-    if not apply:
-        return {
-            "applied": False,
-            "previews": [{"file": str(file_path), "before": before, "after": after}],
-            "message": "Use --apply to apply formatting.",
-        }
-    _ = file_path.write_text(after)
-    return {"applied": True, "message": "Formatted document.", "files": [str(file_path)]}
-
-
-def format_range(
-    file: Path,
-    start_line: int,
-    start_col: int,
-    end_line: int,
-    end_col: int,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not isinstance(router, MultiLSPRouter) or not router.ruff_lsp:
-        return {"applied": False, "message": "Ruff LSP is not enabled or available."}
-    file_path = file if file.is_absolute() else router.root / file
-    uri = router.ruff_lsp.open_document(file_path)
-    params = {
-        "textDocument": {"uri": uri},
-        "range": {
-            "start": {"line": start_line - 1, "character": start_col - 1},
-            "end": {"line": end_line - 1, "character": end_col - 1},
-        },
-        "options": {"tabSize": 4, "insertSpaces": True},
-    }
-    edits = router.ruff_lsp.request("textDocument/rangeFormatting", params)
-    router.ruff_lsp.close_document(uri)
-    if not edits:
-        return {"applied": False, "message": "No formatting changes available."}
-    before = file_path.read_text()
-    after = apply_text_edits(before, edits)
-    if not apply:
-        return {
-            "applied": False,
-            "previews": [{"file": str(file_path), "before": before, "after": after}],
-            "message": "Use --apply to apply formatting.",
-        }
-    _ = file_path.write_text(after)
-    return {"applied": True, "message": "Formatted range.", "files": [str(file_path)]}
-
-
-def organize_imports(
-    file: Path,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    file_path = file if file.is_absolute() else router.root / file
-    return _apply_code_action_by_kind(
-        router,
-        file_path,
-        "source.organizeImports",
-        apply=apply,
-        allow_unsafe=getattr(router.config, "fixes_allow_unsafe", False),
-    )
-
-
-def fix_all(
-    file: Path,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    file_path = file if file.is_absolute() else router.root / file
-    return _apply_code_action_by_kind(
-        router,
-        file_path,
-        "source.fixAll",
-        apply=apply,
-        allow_unsafe=getattr(router.config, "fixes_allow_unsafe", False),
-    )
-
-
-def add_type_ignore_comment(
-    file: str,
-    line: int,
-    col: int,
-    *,
-    error_code: str | None = None,
-    apply: bool = False,
-    confirm_annotations: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Add a type ignore comment to suppress a diagnostic.
-
-    This function searches for code actions that add '# type: ignore' comments
-    at the specified location. If an error_code is provided, it will prefer
-    '# type: ignore[error-code]' format.
-
-    Args:
-        file: Path to the file
-        line: 1-based line number
-        col: 1-based column number
-        error_code: Optional specific error code to ignore (e.g., 'reportOptionalMemberAccess')
-        apply: If True, apply the change; if False, preview only
-        confirm_annotations: Allow edits that require change annotations
-        config_file: Optional path to config file
-        lsp_server: Override LSP server selection
-
-    Returns:
-        Dictionary with preview/apply result
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not router.code_actions or not router.lsp:
-        return {
-            "applied": False,
-            "message": "No LSP server available for code actions.",
-            "error": router.lsp_error,
-        }
-
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    # Get diagnostics at the location to find available ignore actions
-    try:
-        if router.lsp:
-            uri = router.lsp.open_document(file_path)
-            diagnostics_result = router.lsp.request(
-                "textDocument/diagnostic", {"textDocument": {"uri": uri}}
-            )
-            diagnostics = diagnostics_result.get("items", []) if diagnostics_result else []
-        else:
-            diagnostics = []
-    except Exception as exc:
-        logger.debug("Failed to get diagnostics: %s", exc)
-        diagnostics = []
-
-    # Request code actions with diagnostics context
-    actions = router.code_actions.get_code_actions(file_path, line, col, diagnostics=diagnostics)
-
-    # Filter for ignore comment actions
-    ignore_actions = []
-    for action in actions:
-        title = action.get("title", "").lower()
-        # Look for actions related to type ignore comments
-        if (
-            "ignore" in title
-            or "suppress" in title
-            or "pyright: ignore" in title
-            or "type: ignore" in title
-        ):
-            # If error_code specified, prefer actions that include it
-            if error_code:
-                if error_code in title or f"[{error_code}]" in title:
-                    ignore_actions.insert(0, action)  # Prioritize exact match
-                else:
-                    ignore_actions.append(action)
-            else:
-                ignore_actions.append(action)
-
-    if not ignore_actions:
-        return {
-            "applied": False,
-            "message": "No ignore comment actions available at this location.",
-            "actions_available": len(actions),
-            "hint": "Make sure there is a diagnostic at this location that can be suppressed.",
-        }
-
-    # Use the first matching ignore action
-    action = ignore_actions[0]
-
-    if action.get("disabled"):
-        return {
-            "applied": False,
-            "message": "Selected ignore action is disabled by the server.",
-        }
-
-    # Resolve the action if needed
-    resolved = action
-    if "edit" not in action and "data" in action:
-        try:
-            resolved = router.lsp.request("codeAction/resolve", action)
-        except Exception as exc:
-            logger.debug("Failed to resolve code action: %s", exc)
-
-    edit = resolved.get("edit") or action.get("edit")
-    command = resolved.get("command") or action.get("command")
-
-    if edit:
-        needs_confirmation = workspace_edit_needs_confirmation(edit)
-        if apply and needs_confirmation and not confirm_annotations:
-            return {
-                "applied": False,
-                "needs_confirmation": True,
-                "message": "Action requires confirmation via change annotations.",
-            }
-
-        if not apply:
-            preview_map = preview_workspace_edit(edit, root=router.root)
-            previews: list[dict[str, Any]] = []
-            patch_chunks: list[str] = []
-            for path, (before, after) in preview_map.items():
-                patch_chunks.append(build_unified_diff(path, before, after))
-                previews.append(
-                    {
-                        "file": str(path),
-                        "before": before,
-                        "after": after,
-                        "title": action.get("title", "Unnamed action"),
-                        "needs_confirmation": needs_confirmation,
-                    },
-                )
-            return {
-                "applied": False,
-                "previews": previews,
-                "patch": "".join(patch_chunks),
-                "message": "Use --apply to add the ignore comment.",
-                "action_title": action.get("title"),
-            }
-
-        # Apply the edit
-        stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-        backup_dir = router.root / ".vds-lsp" / "backups" / stamp
-        changed = apply_workspace_edit(edit, root=router.root, backup_dir=backup_dir, dry_run=False)
-        return {
-            "applied": bool(changed),
-            "backup_dir": str(backup_dir),
-            "message": "Added type ignore comment." if changed else "No changes applied.",
-            "action_title": action.get("title"),
-        }
-
-    if command:
-        if not apply:
-            return {
-                "applied": False,
-                "command": command,
-                "message": "Use --apply to execute the ignore comment command.",
-                "action_title": action.get("title"),
-            }
-
-        try:
-            payload = command if isinstance(command, dict) else {"command": command}
-            router.lsp.request("workspace/executeCommand", payload)
-            return {
-                "applied": True,
-                "message": "Executed ignore comment command.",
-                "action_title": action.get("title"),
-            }
-        except Exception as exc:
-            logger.debug("Failed to execute ignore comment command: %s", exc)
-            return {
-                "applied": False,
-                "message": f"Failed to execute command: {exc}",
-            }
-
-    return {
-        "applied": False,
-        "message": "No edit or command found in the ignore action.",
-    }
-
-
-def index_workspace(
-    path: Path,
-    force: bool = False,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    progress: Any | None = None,
-    parallel: bool = False,
-    **kwargs: Any,
-):
-    router = _build_router(path, config_file=config_file, lsp_server=lsp_server)
-    return router.indexer.index_directory(force=force, progress=progress, parallel=parallel)
-
-
-def document_highlight(
-    file: str,
-    line: int,
-    col: int,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get document highlights for a symbol at a location.
-
-    Returns all references to the symbol in the current document.
-    Distinguishes between read and write references.
-    Falls back to AST-based search if LSP unavailable.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    # Try LSP first
-    if router.lsp:
-        uri: str | None = None
-        try:
-            uri = router.lsp.open_document(file_path)
-            params = {
-                "textDocument": {"uri": uri},
-                "position": {"line": line - 1, "character": col - 1},
-            }
-            result = router.lsp.request("textDocument/documentHighlight", params)
-            if result:
-                highlights: list[dict[str, Any]] = []
-                for hl in result:
-                    range_info = hl.get("range", {})
-                    start = range_info.get("start", {})
-                    end = range_info.get("end", {})
-                    kind = hl.get("kind", 0)  # 1=Text, 2=Read, 3=Write
-
-                    highlights.append(
-                        {
-                            "range": {
-                                "start": {
-                                    "line": start.get("line", 0) + 1,
-                                    "character": start.get("character", 0) + 1,
-                                },
-                                "end": {
-                                    "line": end.get("line", 0) + 1,
-                                    "character": end.get("character", 0) + 1,
-                                },
-                            },
-                            "kind": kind,
-                            "kind_name": _highlight_kind_name(kind),
-                        },
-                    )
-                return {"source": "lsp", "file": str(file_path), "highlights": highlights}
-        except Exception as exc:
-            logger.debug("LSP document highlight failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback to AST - get symbol at position and search in same file
-    symbol_name = router.indexer.get_symbol_at_position(file_path, line, col)
-    if not symbol_name:
-        return {
-            "source": "ast",
-            "file": str(file_path),
-            "highlights": [],
-            "message": "No symbol found at location",
-        }
-
-    # Get all document symbols and filter for matches
-    # Note: get_document_symbols returns SymbolInformation objects
-    doc_symbols = router.indexer.get_document_symbols(file_path)
-    highlights: list[dict[str, Any]] = []
-
-    for sym in doc_symbols:
-        # SymbolInformation has a location attribute with line/column info
-        if sym.name == symbol_name:
-            loc = sym.location
-            sym_range = {
-                "start": {"line": loc.line, "character": loc.column},
-                "end": {"line": loc.end_line, "character": loc.end_column},
-            }
-            highlights.append(
-                {
-                    "range": sym_range,
-                    "kind": 1,  # Default to Text for AST
-                    "kind_name": "Text",
-                },
-            )
-
-    return {"source": "ast", "file": str(file_path), "highlights": highlights}
-
-
-def _highlight_kind_name(kind: int) -> str:
-    """Convert LSP DocumentHighlightKind to name."""
-    kind_map = {
-        0: "Unknown",
-        1: "Text",
-        2: "Read",
-        3: "Write",
-    }
-    return kind_map.get(kind, "Unknown")
-
-
-def _lsp_symbol_kind_to_name(kind: int) -> str:
-    """Convert LSP SymbolKind number to our SymbolKind string.
-
-    LSP SymbolKind values (from LSP spec):
-    1: File, 2: Module, 3: Namespace, 4: Package, 5: Class,
-    6: Method, 7: Property, 8: Field, 9: Constructor, 10: Enum,
-    11: Interface, 12: Function, 13: Variable, 14: Constant,
-    15: String, 16: Number, 17: Boolean, 18: Array, 19: Object,
-    20: Key, 21: Null, 22: EnumMember, 23: Struct, 24: Event,
-    25: Operator, 26: TypeParameter
-    """
-    kind_map = {
-        1: "File",
-        2: "Module",
-        3: "Namespace",
-        4: "Package",
-        5: "Class",
-        6: "Method",
-        7: "Property",
-        8: "Field",
-        9: "Constructor",
-        10: "Enum",
-        11: "Interface",
-        12: "Function",
-        13: "Variable",
-        14: "Constant",
-        15: "String",
-        16: "Number",
-        17: "Boolean",
-        18: "Array",
-        19: "Object",
-        20: "Key",
-        21: "Null",
-        22: "EnumMember",
-        23: "Struct",
-        24: "Event",
-        25: "Operator",
-        26: "TypeParameter",
-    }
-    return kind_map.get(kind, "Unknown")
-
-
-def document_links(
-    file: str,
-    *,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get document links for a file.
-
-    Returns clickable links found in the document including:
-    - URLs (http/https)
-    - Import statements that resolve to workspace files
-    - Relative file paths in strings
-
-    Falls back to AST-based link detection if LSP unavailable.
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    if not file_path.exists():
-        return {"source": "error", "file": str(file_path), "links": [], "message": "File not found"}
-
-    # Try LSP first
-    if router.lsp:
-        uri: str | None = None
-        try:
-            uri = router.lsp.open_document(file_path)
-            params = {"textDocument": {"uri": uri}}
-            result = router.lsp.request("textDocument/documentLink", params)
-            if result:
-                links: list[dict[str, Any]] = []
-                for link in result:
-                    range_info = link.get("range", {})
-                    start = range_info.get("start", {})
-                    end = range_info.get("end", {})
-                    target = link.get("target")
-                    tooltip = link.get("tooltip", "")
-
-                    link_info = {
-                        "range": {
-                            "start": {
-                                "line": start.get("line", 0) + 1,
-                                "character": start.get("character", 0) + 1,
-                            },
-                            "end": {
-                                "line": end.get("line", 0) + 1,
-                                "character": end.get("character", 0) + 1,
-                            },
-                        },
-                    }
-                    if target:
-                        link_info["target"] = target
-                    if tooltip:
-                        link_info["tooltip"] = tooltip
-                    links.append(link_info)
-                return {"source": "lsp", "file": str(file_path), "links": links}
-        except Exception as exc:
-            logger.debug("LSP document link failed: %s", exc)
-        finally:
-            if uri and router.lsp:
-                router.lsp.close_document(uri)
-
-    # Fallback to AST-based link detection
-    links: list[dict[str, Any]] = []
-    try:
-        content = file_path.read_text()
-        lines = content.splitlines()
-
-        import re
-
-        # Pattern 1: URLs (http/https)
-        url_pattern = re.compile(r"https?://[^\s\"'<>]+")
-
-        # Pattern 2: Relative file paths in strings (basic detection)
-        # Matches strings that look like relative paths: "./foo", "../bar", "path/to/file"
-        rel_path_pattern = re.compile(
-            r'["\']([\.A-Za-z_][\w\.\/\-\\\ ]+\.(?:py|txt|md|json|yaml|yml|toml|cfg|ini))["\']'
-        )
-
-        # Pattern 3: Import statements
-        import_pattern = re.compile(r"^\s*(?:from|import)\s+([\w\.]+)")
-
-        for line_idx, line in enumerate(lines, start=1):
-            # Find URLs
-            for match in url_pattern.finditer(line):
-                links.append(
-                    {
-                        "range": {
-                            "start": {"line": line_idx, "character": match.start() + 1},
-                            "end": {"line": line_idx, "character": match.end() + 1},
-                        },
-                        "target": match.group(0),
-                        "kind": "url",
-                    }
-                )
-
-            # Find relative paths in strings
-            for match in rel_path_pattern.finditer(line):
-                path_str = match.group(1)
-                # Try to resolve relative to current file
-                try:
-                    resolved = (file_path.parent / path_str).resolve()
-                    if resolved.exists():
-                        links.append(
-                            {
-                                "range": {
-                                    "start": {"line": line_idx, "character": match.start(1) + 1},
-                                    "end": {"line": line_idx, "character": match.end(1) + 1},
-                                },
-                                "target": str(resolved),
-                                "kind": "file",
-                            }
-                        )
-                except Exception:
-                    pass
-
-            # Find import statements
-            for match in import_pattern.finditer(line):
-                module_name = match.group(1)
-                links.append(
-                    {
-                        "range": {
-                            "start": {"line": line_idx, "character": match.start(1) + 1},
-                            "end": {"line": line_idx, "character": match.end(1) + 1},
-                        },
-                        "target": module_name,
-                        "kind": "import",
-                    }
-                )
-
-    except Exception as exc:
-        logger.debug("AST link detection failed: %s", exc)
-
-    return {"source": "ast", "file": str(file_path), "links": links}
-
-
-# ============================================================================
-# Batch Operations
-# ============================================================================
-
-
-def _collect_python_files(
-    paths: list[Path],
-    root: Path,
-    *,
-    include_paths: list[Path] | None = None,
-    exclude_paths: list[Path] | None = None,
-    git_tracked_only: bool = False,
-) -> list[Path]:
-    """Collect Python files from given paths for batch operations.
-
-    Args:
-        paths: List of file/directory paths to process
-        root: Root path for resolving relative paths
-        include_paths: Optional list of paths to include (filters)
-        exclude_paths: Optional list of paths to exclude
-        git_tracked_only: If True, only include git-tracked files
-
-    Returns:
-        List of Python file paths to process
-    """
-
-    # Ensure root is absolute for path comparisons
-    root = root.resolve()
-    files: list[Path] = []
-    seen: set[Path] = set()
-
-    # Convert filters to Path objects
-    include_set = {p.resolve() for p in include_paths} if include_paths else None
-    exclude_set = {p.resolve() for p in exclude_paths} if exclude_paths else None
-
-    # Get git tracked files if requested
-    git_files: set[Path] | None = None
-    if git_tracked_only:
-        try:
-            result = subprocess.run(
-                ["git", "ls-files", "*.py"],
-                cwd=root,
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            git_files = {root / f for f in result.stdout.splitlines() if f}
-        except FileNotFoundError:
-            logger.warning("git not found, skipping git-tracked filter")
-
-    for path in paths:
-        resolved = path if path.is_absolute() else root / path
-        if not resolved.exists():
-            continue
-
-        if resolved.is_file():
-            if resolved.suffix == ".py":
-                files.append(resolved)
-            continue
-
-        # Directory: walk recursively
-        for item in resolved.rglob("*.py"):
-            if item in seen:
-                continue
-            seen.add(item)
-
-            # Apply include filter
-            if include_set:
-                rel_path = item.relative_to(root)
-                included = False
-                for inc in include_set:
-                    if not inc.is_relative_to(root):
-                        continue
-                    inc_rel = inc.relative_to(root)
-                    # Check if include path is a file (exact match)
-                    if inc_rel == rel_path:
-                        included = True
-                        break
-                    # Check if include path is a directory (relative to)
-                    if rel_path.is_relative_to(inc_rel):
-                        included = True
-                        break
-                if not included:
-                    continue
-
-            # Apply exclude filter
-            if exclude_set:
-                rel_path = item.relative_to(root)
-                excluded = False
-                for exc in exclude_set:
-                    if not exc.is_relative_to(root):
-                        continue
-                    exc_rel = exc.relative_to(root)
-                    # Check if exclude path is a file (exact match)
-                    if exc_rel == rel_path:
-                        excluded = True
-                        break
-                    # Check if exclude path is a directory (relative to)
-                    if rel_path.is_relative_to(exc_rel):
-                        excluded = True
-                        break
-                if excluded:
-                    continue
-
-            # Apply git filter
-            if git_files is not None and item not in git_files:
-                continue
-
-            files.append(item)
-
-    return sorted(files)
-
-
-def _create_backup_dir(root: Path) -> Path:
-    """Create a backup directory for atomic batch operations."""
-
-    backup_root = root / ".vds-lsp" / "backups"
-    backup_root.mkdir(parents=True, exist_ok=True)
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    backup_dir = backup_root / timestamp
-    backup_dir.mkdir(exist_ok=True)
-    return backup_dir
-
-
-def _backup_files(files: list[Path], backup_dir: Path) -> dict[Path, Path]:
-    """Backup files to backup directory, maintaining directory structure.
-
-    Returns:
-        Dictionary mapping original file to backup file path
-    """
-    backups: dict[Path, Path] = {}
-    for file_path in files:
-        rel_path = file_path.relative_to(file_path.anchor)
-        backup_file = backup_dir / rel_path
-        backup_file.parent.mkdir(parents=True, exist_ok=True)
-        _ = shutil.copy2(file_path, backup_file)
-        backups[file_path] = backup_file
-    return backups
-
-
-def _process_file_parallel(
-    file_path: Path,
-    operation: str,
-    apply: bool,
-    config_file: Path | None,
-    lsp_server: str | None,
-) -> dict[str, Any]:
-    """Process a single file operation in parallel.
-
-    Args:
-        file_path: Path to file to process
-        operation: Operation to perform ('format', 'organize_imports', 'fix_all')
-        apply: Whether to apply changes
-        config_file: Optional config file path
-        lsp_server: Optional LSP server override
-
-    Returns:
-        Dictionary with operation result
-    """
-    try:
-        if operation == "format":
-            result = format_document(
-                file_path, apply=apply, config_file=config_file, lsp_server=lsp_server
-            )
-        elif operation == "organize_imports":
-            result = organize_imports(
-                file_path, apply=apply, config_file=config_file, lsp_server=lsp_server
-            )
-        elif operation == "fix_all":
-            result = fix_all(file_path, apply=apply, config_file=config_file, lsp_server=lsp_server)
-        else:
-            return {"file": file_path, "error": f"Unknown operation: {operation}"}
-
-        return {"file": file_path, "result": result, "success": True}
-    except Exception as exc:
-        logger.exception("Failed to %s %s: %s", operation, file_path, exc)
-        return {"file": file_path, "error": str(exc), "success": False}
-
-
-def batch_format(
-    paths: list[Path],
-    *,
-    apply: bool = False,
-    atomic: bool = True,
-    include_paths: list[Path] | None = None,
-    exclude_paths: list[Path] | None = None,
-    git_tracked_only: bool = False,
-    parallel: bool = True,
-    jobs: int | None = None,
-    progress: Any | None = None,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """Format multiple Python files using Ruff LSP.
-
-    Args:
-        paths: List of file/directory paths to format
-        apply: If True, apply formatting changes; otherwise preview only
-        atomic: If True, backup all files and rollback on error
-        include_paths: Optional list of paths to include (filters)
-        exclude_paths: Optional list of paths to exclude
-        git_tracked_only: If True, only process git-tracked files
-        parallel: If True, process files in parallel using ThreadPoolExecutor
-        jobs: Number of parallel jobs (None = auto-detect based on CPU count)
-        progress: Optional Rich Progress object for UI updates
-        config_file: Optional path to pyright config file
-        lsp_server: Optional LSP server command override
-
-    Returns:
-        Dictionary with results including files modified, previews, and summary
-    """
-
-    router = _build_router(
-        paths[0] if paths else Path.cwd(), config_file=config_file, lsp_server=lsp_server
-    )
-    if not isinstance(router, MultiLSPRouter) or not router.ruff_lsp:
-        return {"success": False, "message": "Ruff LSP is not enabled or available."}
-
-    files = _collect_python_files(
-        paths,
-        router.root,
-        include_paths=include_paths,
-        exclude_paths=exclude_paths,
-        git_tracked_only=git_tracked_only,
-    )
-
-    if not files:
-        return {"success": True, "processed": 0, "message": "No Python files found to process."}
-
-    backup_dir: Path | None = None
-    backups: dict[Path, Path] | None = None
-
-    if atomic and apply:
-        backup_dir = _create_backup_dir(router.root)
-        backups = _backup_files(files, backup_dir)
-
-    results: list[dict[str, Any]] = []
-    errors: list[dict[str, Any]] = []
-    modified: list[Path] = []
-
-    task_id = None
-    if progress:
-        task_id = progress.add_task("Formatting files...", total=len(files))
-
-    # Process files (parallel or sequential)
-    if parallel and len(files) > 1:
-        import os
-
-        # Default to CPU count or 4, whichever is smaller
-        max_workers = jobs or min(os.cpu_count() or 4, 8)
-        if max_workers > len(files):
-            max_workers = len(files)
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = {
-                executor.submit(
-                    _process_file_parallel,
-                    file_path,
-                    "format",
-                    apply and not atomic,
-                    config_file,
-                    lsp_server,
-                ): file_path
-                for file_path in files
-            }
-
-            for future in as_completed(futures):
-                file_path = futures[future]
-                try:
-                    result = future.result()
-                    if result.get("success"):
-                        op_result = result.get("result", {})
-                        if atomic and apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                        elif apply and op_result.get("applied"):
-                            modified.append(file_path)
-                        elif not apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                    else:
-                        errors.append(
-                            {"file": str(file_path), "error": result.get("error", "Unknown error")}
-                        )
-                        logger.error("Failed to format %s: %s", file_path, result.get("error"))
-                        if atomic and apply and backups:
-                            # Rollback on error
-                            for orig, backup in backups.items():
-                                _ = shutil.copy2(backup, orig)
-                            return {
-                                "success": False,
-                                "processed": len(results),
-                                "errors": errors,
-                                "backup_dir": str(backup_dir),
-                                "message": f"Rolled back due to error formatting {file_path}",
-                            }
-                except Exception as exc:
-                    errors.append({"file": str(file_path), "error": str(exc)})
-                    logger.exception("Failed to format %s: %s", file_path, exc)
-                    if atomic and apply and backups:
-                        # Rollback on error
-                        for orig, backup in backups.items():
-                            _ = shutil.copy2(backup, orig)
-                        return {
-                            "success": False,
-                            "processed": len(results),
-                            "errors": errors,
-                            "backup_dir": str(backup_dir),
-                            "message": f"Rolled back due to error formatting {file_path}",
-                        }
-                finally:
-                    if progress and task_id is not None:
-                        progress.update(task_id, advance=1)
-    else:
-        # Sequential processing (original behavior)
-        for file_path in files:
-            try:
-                result = format_document(
-                    file_path,
-                    apply=apply and not atomic,
-                    config_file=config_file,
-                    lsp_server=lsp_server,
-                )
-                if atomic and apply and result.get("previews"):
-                    # Store preview for atomic application
-                    results.append({"file": file_path, "result": result})
-                elif apply and result.get("applied"):
-                    modified.append(file_path)
-                elif not apply and result.get("previews"):
-                    results.append({"file": file_path, "result": result})
-            except Exception as exc:
-                errors.append({"file": str(file_path), "error": str(exc)})
-                logger.exception("Failed to format %s: %s", file_path, exc)
-                if atomic and apply and backups:
-                    # Rollback on error
-                    for orig, backup in backups.items():
-                        _ = shutil.copy2(backup, orig)
-                    return {
-                        "success": False,
-                        "processed": len(results),
-                        "errors": errors,
-                        "backup_dir": str(backup_dir),
-                        "message": f"Rolled back due to error formatting {file_path}",
-                    }
-            finally:
-                if progress and task_id is not None:
-                    progress.update(task_id, advance=1)
-
-    # Apply all changes atomically if needed
-    if atomic and apply and backups:
-        for item in results:
-            file_path = item["file"]
-            result = item["result"]
-            if result.get("previews"):
-                preview = result["previews"][0]
-                file_path.write_text(preview["after"])
-                modified.append(file_path)
-
-    previews: list[dict[str, Any]] = []
-    for item in results:
-        result = item["result"]
-        if result.get("previews"):
-            previews.extend(result["previews"])
-
-    return {
-        "success": len(errors) == 0,
-        "processed": len(files),
-        "modified": len(modified),
-        "errors": len(errors),
-        "files": [str(f) for f in modified],
-        "previews": previews if not apply else [],
-        "error_details": errors,
-        "backup_dir": str(backup_dir) if backup_dir else None,
-        "parallel": parallel,
-        "max_workers": jobs if jobs else ("auto" if parallel else 1),
-        "message": f"Processed {len(files)} files, modified {len(modified)} files with {len(errors)} errors.",
-    }
-
-
-def batch_organize_imports(
-    paths: list[Path],
-    *,
-    apply: bool = False,
-    atomic: bool = True,
-    include_paths: list[Path] | None = None,
-    exclude_paths: list[Path] | None = None,
-    git_tracked_only: bool = False,
-    parallel: bool = True,
-    jobs: int | None = None,
-    progress: Any | None = None,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """Organize imports across multiple Python files.
-
-    Args:
-        paths: List of file/directory paths to process
-        apply: If True, apply import organization; otherwise preview only
-        atomic: If True, backup all files and rollback on error
-        include_paths: Optional list of paths to include (filters)
-        exclude_paths: Optional list of paths to exclude
-        git_tracked_only: If True, only process git-tracked files
-        parallel: If True, process files in parallel using ThreadPoolExecutor
-        jobs: Number of parallel jobs (None = auto-detect based on CPU count)
-        progress: Optional Rich Progress object for UI updates
-        config_file: Optional path to pyright config file
-        lsp_server: Optional LSP server command override
-
-    Returns:
-        Dictionary with results including files modified, previews, and summary
-    """
-    router = _build_router(
-        paths[0] if paths else Path.cwd(), config_file=config_file, lsp_server=lsp_server
-    )
-
-    files = _collect_python_files(
-        paths,
-        router.root,
-        include_paths=include_paths,
-        exclude_paths=exclude_paths,
-        git_tracked_only=git_tracked_only,
-    )
-
-    if not files:
-        return {"success": True, "processed": 0, "message": "No Python files found to process."}
-
-    backup_dir: Path | None = None
-    backups: dict[Path, Path] | None = None
-
-    if atomic and apply:
-        backup_dir = _create_backup_dir(router.root)
-        backups = _backup_files(files, backup_dir)
-
-    results: list[dict[str, Any]] = []
-    errors: list[dict[str, Any]] = []
-    modified: list[Path] = []
-
-    task_id = None
-    if progress:
-        task_id = progress.add_task("Organizing imports...", total=len(files))
-
-    # Process files (parallel or sequential)
-    if parallel and len(files) > 1:
-        import os
-
-        # Default to CPU count or 4, whichever is smaller
-        max_workers = jobs or min(os.cpu_count() or 4, 8)
-        if max_workers > len(files):
-            max_workers = len(files)
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = {
-                executor.submit(
-                    _process_file_parallel,
-                    file_path,
-                    "organize_imports",
-                    apply and not atomic,
-                    config_file,
-                    lsp_server,
-                ): file_path
-                for file_path in files
-            }
-
-            for future in as_completed(futures):
-                file_path = futures[future]
-                try:
-                    result = future.result()
-                    if result.get("success"):
-                        op_result = result.get("result", {})
-                        if atomic and apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                        elif apply and op_result.get("applied"):
-                            modified.append(file_path)
-                        elif not apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                    else:
-                        errors.append(
-                            {"file": str(file_path), "error": result.get("error", "Unknown error")}
-                        )
-                        logger.error(
-                            "Failed to organize imports in %s: %s", file_path, result.get("error")
-                        )
-                        if atomic and apply and backups:
-                            # Rollback on error
-                            for orig, backup in backups.items():
-                                _ = shutil.copy2(backup, orig)
-                            return {
-                                "success": False,
-                                "processed": len(results),
-                                "errors": errors,
-                                "backup_dir": str(backup_dir),
-                                "message": f"Rolled back due to error organizing imports in {file_path}",
-                            }
-                except Exception as exc:
-                    errors.append({"file": str(file_path), "error": str(exc)})
-                    logger.exception("Failed to organize imports in %s: %s", file_path, exc)
-                    if atomic and apply and backups:
-                        # Rollback on error
-                        for orig, backup in backups.items():
-                            _ = shutil.copy2(backup, orig)
-                        return {
-                            "success": False,
-                            "processed": len(results),
-                            "errors": errors,
-                            "backup_dir": str(backup_dir),
-                            "message": f"Rolled back due to error organizing imports in {file_path}",
-                        }
-                finally:
-                    if progress and task_id is not None:
-                        progress.update(task_id, advance=1)
-    else:
-        # Sequential processing (original behavior)
-        for file_path in files:
-            try:
-                result = organize_imports(
-                    file_path,
-                    apply=apply and not atomic,
-                    config_file=config_file,
-                    lsp_server=lsp_server,
-                )
-                if atomic and apply and result.get("previews"):
-                    results.append({"file": file_path, "result": result})
-                elif apply and result.get("applied"):
-                    modified.append(file_path)
-                elif not apply and result.get("previews"):
-                    results.append({"file": file_path, "result": result})
-            except Exception as exc:
-                errors.append({"file": str(file_path), "error": str(exc)})
-                logger.exception("Failed to organize imports in %s: %s", file_path, exc)
-                if atomic and apply and backups:
-                    for orig, backup in backups.items():
-                        _ = shutil.copy2(backup, orig)
-                    return {
-                        "success": False,
-                        "processed": len(results),
-                        "errors": errors,
-                        "backup_dir": str(backup_dir),
-                        "message": f"Rolled back due to error organizing imports in {file_path}",
-                    }
-            finally:
-                if progress and task_id is not None:
-                    progress.update(task_id, advance=1)
-
-    if atomic and apply and backups:
-        for item in results:
-            file_path = item["file"]
-            result = item["result"]
-            if result.get("previews"):
-                preview = result["previews"][0]
-                file_path.write_text(preview["after"])
-                modified.append(file_path)
-
-    previews: list[dict[str, Any]] = []
-    for item in results:
-        result = item["result"]
-        if result.get("previews"):
-            previews.extend(result["previews"])
-
-    return {
-        "success": len(errors) == 0,
-        "processed": len(files),
-        "modified": len(modified),
-        "errors": len(errors),
-        "files": [str(f) for f in modified],
-        "previews": previews if not apply else [],
-        "error_details": errors,
-        "backup_dir": str(backup_dir) if backup_dir else None,
-        "parallel": parallel,
-        "max_workers": jobs if jobs else ("auto" if parallel else 1),
-        "message": f"Processed {len(files)} files, modified {len(modified)} files with {len(errors)} errors.",
-    }
-
-
-def batch_fix_all(
-    paths: list[Path],
-    *,
-    apply: bool = False,
-    atomic: bool = True,
-    include_paths: list[Path] | None = None,
-    exclude_paths: list[Path] | None = None,
-    git_tracked_only: bool = False,
-    parallel: bool = True,
-    jobs: int | None = None,
-    progress: Any | None = None,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    **kwargs: Any,
-) -> dict[str, Any]:
-    """Apply fix-all code actions across multiple Python files.
-
-    Args:
-        paths: List of file/directory paths to process
-        apply: If True, apply fixes; otherwise preview only
-        atomic: If True, backup all files and rollback on error
-        include_paths: Optional list of paths to include (filters)
-        exclude_paths: Optional list of paths to exclude
-        git_tracked_only: If True, only process git-tracked files
-        parallel: If True, process files in parallel using ThreadPoolExecutor
-        jobs: Number of parallel jobs (None = auto-detect based on CPU count)
-        progress: Optional Rich Progress object for UI updates
-        config_file: Optional path to pyright config file
-        lsp_server: Optional LSP server command override
-
-    Returns:
-        Dictionary with results including files modified, previews, and summary
-    """
-    router = _build_router(
-        paths[0] if paths else Path.cwd(), config_file=config_file, lsp_server=lsp_server
-    )
-
-    files = _collect_python_files(
-        paths,
-        router.root,
-        include_paths=include_paths,
-        exclude_paths=exclude_paths,
-        git_tracked_only=git_tracked_only,
-    )
-
-    if not files:
-        return {"success": True, "processed": 0, "message": "No Python files found to process."}
-
-    backup_dir: Path | None = None
-    backups: dict[Path, Path] | None = None
-
-    if atomic and apply:
-        backup_dir = _create_backup_dir(router.root)
-        backups = _backup_files(files, backup_dir)
-
-    results: list[dict[str, Any]] = []
-    errors: list[dict[str, Any]] = []
-    modified: list[Path] = []
-
-    task_id = None
-    if progress:
-        task_id = progress.add_task("Applying fixes...", total=len(files))
-
-    # Process files (parallel or sequential)
-    if parallel and len(files) > 1:
-        import os
-
-        # Default to CPU count or 4, whichever is smaller
-        max_workers = jobs or min(os.cpu_count() or 4, 8)
-        if max_workers > len(files):
-            max_workers = len(files)
-
-        with ThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = {
-                executor.submit(
-                    _process_file_parallel,
-                    file_path,
-                    "fix_all",
-                    apply and not atomic,
-                    config_file,
-                    lsp_server,
-                ): file_path
-                for file_path in files
-            }
-
-            for future in as_completed(futures):
-                file_path = futures[future]
-                try:
-                    result = future.result()
-                    if result.get("success"):
-                        op_result = result.get("result", {})
-                        if atomic and apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                        elif apply and op_result.get("applied"):
-                            modified.append(file_path)
-                        elif not apply and op_result.get("previews"):
-                            results.append({"file": file_path, "result": op_result})
-                    else:
-                        errors.append(
-                            {"file": str(file_path), "error": result.get("error", "Unknown error")}
-                        )
-                        logger.error(
-                            "Failed to apply fixes to %s: %s", file_path, result.get("error")
-                        )
-                        if atomic and apply and backups:
-                            # Rollback on error
-                            for orig, backup in backups.items():
-                                _ = shutil.copy2(backup, orig)
-                            return {
-                                "success": False,
-                                "processed": len(results),
-                                "errors": errors,
-                                "backup_dir": str(backup_dir),
-                                "message": f"Rolled back due to error applying fixes to {file_path}",
-                            }
-                except Exception as exc:
-                    errors.append({"file": str(file_path), "error": str(exc)})
-                    logger.exception("Failed to apply fixes to %s: %s", file_path, exc)
-                    if atomic and apply and backups:
-                        # Rollback on error
-                        for orig, backup in backups.items():
-                            _ = shutil.copy2(backup, orig)
-                        return {
-                            "success": False,
-                            "processed": len(results),
-                            "errors": errors,
-                            "backup_dir": str(backup_dir),
-                            "message": f"Rolled back due to error applying fixes to {file_path}",
-                        }
-                finally:
-                    if progress and task_id is not None:
-                        progress.update(task_id, advance=1)
-    else:
-        # Sequential processing (original behavior)
-        for file_path in files:
-            try:
-                result = fix_all(
-                    file_path,
-                    apply=apply and not atomic,
-                    config_file=config_file,
-                    lsp_server=lsp_server,
-                )
-                if atomic and apply and result.get("previews"):
-                    results.append({"file": file_path, "result": result})
-                elif apply and result.get("applied"):
-                    modified.append(file_path)
-                elif not apply and result.get("previews"):
-                    results.append({"file": file_path, "result": result})
-            except Exception as exc:
-                errors.append({"file": str(file_path), "error": str(exc)})
-                logger.exception("Failed to apply fixes to %s: %s", file_path, exc)
-                if atomic and apply and backups:
-                    for orig, backup in backups.items():
-                        _ = shutil.copy2(backup, orig)
-                    return {
-                        "success": False,
-                        "processed": len(results),
-                        "errors": errors,
-                        "backup_dir": str(backup_dir),
-                        "message": f"Rolled back due to error applying fixes to {file_path}",
-                    }
-            finally:
-                if progress and task_id is not None:
-                    progress.update(task_id, advance=1)
-
-    if atomic and apply and backups:
-        for item in results:
-            file_path = item["file"]
-            result = item["result"]
-            if result.get("previews"):
-                preview = result["previews"][0]
-                file_path.write_text(preview["after"])
-                modified.append(file_path)
-
-    previews: list[dict[str, Any]] = []
-    for item in results:
-        result = item["result"]
-        if result.get("previews"):
-            previews.extend(result["previews"])
-
-    return {
-        "success": len(errors) == 0,
-        "processed": len(files),
-        "modified": len(modified),
-        "errors": len(errors),
-        "files": [str(f) for f in modified],
-        "previews": previews if not apply else [],
-        "error_details": errors,
-        "backup_dir": str(backup_dir) if backup_dir else None,
-        "parallel": parallel,
-        "max_workers": jobs if jobs else ("auto" if parallel else 1),
-        "message": f"Processed {len(files)} files, modified {len(modified)} files with {len(errors)} errors.",
-    }
-
-
-# ============================================================================
-# Import Suggestions
-# ============================================================================
-
-
-def suggest_imports(
-    file: str,
-    line: int,
-    col: int,
-    *,
-    apply: bool = False,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-) -> dict[str, Any]:
-    """Get import suggestions for a location in a file.
-
-    This is a convenience wrapper around code actions that filters for
-    import-related actions (BasedPyright's auto-import feature).
-
-    Args:
-        file: Path to the file
-        line: 1-based line number
-        col: 1-based column number
-        apply: If True, apply the first import suggestion
-        config_file: Optional config file path
-        lsp_server: Optional LSP server override
-
-    Returns:
-        Dict with keys:
-        - suggestions: List of import suggestion dicts with title, kind, edit
-        - applied: True if a suggestion was applied
-        - message: Status message
-    """
-    router = _build_router(None, config_file=config_file, lsp_server=lsp_server)
-    if not router.code_actions or not router.lsp:
-        return {
-            "suggestions": [],
-            "applied": False,
-            "message": "No LSP server available for import suggestions.",
-            "error": router.lsp_error,
-        }
-
-    file_path = Path(file)
-    if not file_path.is_absolute():
-        file_path = router.root / file_path
-
-    # Get all code actions at the location
-    all_actions = router.code_actions.get_code_actions(file_path, line, col)
-
-    # Filter for import-related actions
-    # BasedPyright's auto-import actions typically have titles like:
-    # "Import {name} from {module}" or "from {module} import {name}"
-    import_actions = []
-    for action in all_actions:
-        title = action.get("title", "")
-        kind = action.get("kind", "")
-
-        # Filter by import-related keywords in title or kind
-        if (
-            any(keyword in title.lower() for keyword in ("import ", "from "))
-            or kind
-            and ("import" in kind.lower())
-        ):
-            import_actions.append(action)
-
-    if not import_actions:
-        return {
-            "suggestions": [],
-            "applied": False,
-            "message": "No import suggestions available at this location.",
-        }
-
-    # Build response with import suggestions
-    suggestions = []
-    for action in import_actions:
-        suggestion = {
-            "title": action.get("title", "Unnamed suggestion"),
-            "kind": action.get("kind", "unknown"),
-            "category": action.get("category", "source"),
-        }
-
-        # Include edit if available
-        if "edit" in action:
-            suggestion["has_edit"] = True
-            # Try to extract import details from the edit
-            edit = action.get("edit")
-            if edit and edit.get("documentChanges"):
-                changes = edit["documentChanges"][0].get("edits", [])
-                if changes:
-                    # Extract the new import text
-                    new_text = changes[0].get("newText", "")
-                    suggestion["preview"] = new_text.strip()
-        else:
-            suggestion["has_edit"] = False
-
-        suggestions.append(suggestion)
-
-    # Apply first suggestion if requested
-    if apply and suggestions:
-        action = import_actions[0]
-        edit = action.get("edit")
-
-        if edit:
-            # Create backup
-            stamp = datetime.utcnow().strftime("%Y%m%d-%H%M%S")
-            backup_dir = router.root / ".vds-lsp" / "backups" / stamp
-
-            # Apply the edit
-            changed = apply_workspace_edit(
-                edit, root=router.root, backup_dir=backup_dir, dry_run=False
-            )
-
-            return {
-                "suggestions": suggestions,
-                "applied": bool(changed),
-                "backup_dir": str(backup_dir),
-                "applied_suggestion": action.get("title"),
-                "message": f"Applied import suggestion: {action.get('title')}"
-                if changed
-                else "Failed to apply import suggestion.",
-            }
-
-    return {
-        "suggestions": suggestions,
-        "applied": False,
-        "message": f"Found {len(suggestions)} import suggestion(s). Use --apply to add the import.",
-    }
-
-
-# ============================================================================
-# Daemon Operations
-# ============================================================================
-
-
-def daemon_start(
-    root: Path,
-    *,
-    timeout: int = 30,
-    idle_timeout: int = 300,
-    max_clients: int = 10,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    hot_reload: bool = True,
-) -> dict[str, Any]:
-    """Start the LSP daemon for a workspace.
-
-    Args:
-        root: Workspace root directory
-        timeout: Maximum time to wait for daemon to start (seconds)
-        idle_timeout: Daemon idle timeout before auto-shutdown (seconds)
-        max_clients: Maximum concurrent clients allowed
-        config_file: Optional config file path
-        lsp_server: Optional LSP server override
-        hot_reload: Enable configuration hot reload (default: True)
-
-    Returns:
-        Status dict with keys: status, socket, pid, message
-    """
-    from .daemon_manager import get_daemon_manager
-
-    root_path = root if root.is_absolute() else Path.cwd() / root
-    manager = get_daemon_manager(root_path, config_file=config_file)
-
-    # Override idle timeout if specified
-    if idle_timeout != 300:
-        manager.config.daemon_idle_timeout = idle_timeout
-
-    # Override max_clients if specified
-    if max_clients != 10:
-        manager.config.daemon_max_clients = max_clients
-
-    # Override LSP server if specified
-    if lsp_server is not None:
-        manager.config.server_path = lsp_server
-
-    # Override hot_reload if specified
-    manager.config.hot_reload = hot_reload
-
-    return manager.start(
-        timeout=timeout, idle_timeout=idle_timeout, max_clients=max_clients, hot_reload=hot_reload
-    )
-
-
-def daemon_stop(
-    root: Path,
-    *,
-    force: bool = False,
-    config_file: Path | None = None,
-) -> dict[str, Any]:
-    """Stop the LSP daemon for a workspace.
-
-    Args:
-        root: Workspace root directory
-        force: If True, send SIGKILL instead of SIGTERM
-        config_file: Optional config file path
-
-    Returns:
-        Status dict with keys: status, message
-    """
-    from .daemon_manager import get_daemon_manager
-
-    root_path = root if root.is_absolute() else Path.cwd() / root
-    manager = get_daemon_manager(root_path, config_file=config_file)
-    return manager.stop(force=force)
-
-
-def daemon_status(
-    root: Path,
-    *,
-    config_file: Path | None = None,
-) -> dict[str, Any]:
-    """Get the status of the LSP daemon for a workspace.
-
-    Args:
-        root: Workspace root directory
-        config_file: Optional config file path
-
-    Returns:
-        DaemonStatus dict with keys: running, pid, socket_path, uptime_seconds, etc.
-    """
-    from .daemon_manager import get_daemon_manager
-
-    root_path = root if root.is_absolute() else Path.cwd() / root
-    manager = get_daemon_manager(root_path, config_file=config_file)
-    return manager.status()
-
-
-def daemon_restart(
-    root: Path,
-    *,
-    timeout: int = 30,
-    idle_timeout: int = 300,
-    max_clients: int = 10,
-    config_file: Path | None = None,
-    lsp_server: str | None = None,
-    hot_reload: bool = True,
-) -> dict[str, Any]:
-    """Restart the LSP daemon for a workspace.
-
-    Args:
-        root: Workspace root directory
-        timeout: Maximum time to wait for daemon to start (seconds)
-        idle_timeout: Daemon idle timeout before auto-shutdown (seconds)
-        max_clients: Maximum concurrent clients allowed
-        config_file: Optional config file path
-        lsp_server: Optional LSP server override
-        hot_reload: Enable configuration hot reload (default: True)
-
-    Returns:
-        Status dict
-    """
-    from .daemon_manager import get_daemon_manager
-
-    root_path = root if root.is_absolute() else Path.cwd() / root
-    manager = get_daemon_manager(root_path, config_file=config_file)
-
-    # Override idle timeout if specified
-    if idle_timeout != 300:
-        manager.config.daemon_idle_timeout = idle_timeout
-
-    # Override max_clients if specified
-    if max_clients != 10:
-        manager.config.daemon_max_clients = max_clients
-
-    # Override LSP server if specified
-    if lsp_server is not None:
-        manager.config.server_path = lsp_server
-
-    # Override hot_reload if specified
-    manager.config.hot_reload = hot_reload
-
-    return manager.restart(
-        timeout=timeout, idle_timeout=idle_timeout, max_clients=max_clients, hot_reload=hot_reload
-    )
-
-
-def use_daemon(
-    root: Path,
-    *,
-    config_file: Path | None = None,
-) -> bool:
-    """Check if daemon mode is enabled for a workspace.
-
-    Args:
-        root: Workspace root directory
-        config_file: Optional config file path
-
-    Returns:
-        True if daemon mode is enabled and daemon is running
-    """
-    root_path = root if root.is_absolute() else Path.cwd() / root
-    config = load_config(root_path, config_file=config_file)
-
-    logger.info("use_daemon() check: root=%s", root_path)
-    logger.info("  config.daemon_enabled=%s", getattr(config, "daemon_enabled", False))
-
-    if not getattr(config, "daemon_enabled", False):
-        logger.info("  -> Returning False (daemon not enabled in config)")
-        return False
-
-    # Check if daemon is actually running
-    from .daemon_manager import get_daemon_manager
-
-    manager = get_daemon_manager(root_path, config_file=config_file)
-    logger.info("  daemon socket_path=%s", manager.socket_path)
-    logger.info("  daemon pid_file=%s", manager._get_pid_file())
-    is_running = manager.is_running()
-    logger.info("  manager.is_running()=%s", is_running)
-    logger.info("  -> Returning %s", is_running)
-    return is_running
-
-
-def get_daemon_client(
-    root: Path,
-    *,
-    config_file: Path | None = None,
-):
-    """Get a daemon client for the workspace.
-
-    Args:
-        root: Workspace root directory
-        config_file: Optional config file path
-
-    Returns:
-        DaemonClient instance if available, None otherwise
-
-    Raises:
-        ConnectionError: If daemon is enabled but not running
-    """
-    from .daemon_client import (
-        get_daemon_client as _get_daemon_client,
-    )
-
-    root_path = root if root.is_absolute() else Path.cwd() / root
-
-    client = _get_daemon_client(root_path, config_file=config_file)
-
-    if not client.is_available():
-        raise ConnectionError(
-            f"Daemon is not running for workspace: {root_path}. "
-            f"Start it with: vds-lsp-orchestrator daemon start",
-        )
-
-    return client
-
-
-class DaemonLspClient:
-    """Daemon-based LSP client that provides the same interface as LspClient.
-
-    This wraps DaemonClient to provide compatibility with LSPRouter and existing
-    LSP operations. When daemon mode is enabled, this client is used instead of
-    the direct stdio-based LspClient.
-    """
-
-    def __init__(self, root: Path, config: Any, daemon_client: Any):
-        """Initialize daemon LSP client.
-
-        Args:
-            root: Workspace root directory
-            config: LSP configuration
-            daemon_client: DaemonClient instance
-        """
-        self.root = root
-        self.config = config
-        self.daemon = daemon_client
-
-    def start(self):
-        """Start the client (no-op for daemon mode)."""
-
-    def stop(self):
-        """Stop the client (no-op for daemon mode - daemon manages its own lifecycle)."""
-
-    def open_document(self, file_path: Path, wait_for_diagnostics: bool = False) -> str:
-        """Open a document in the LSP server and return its URI.
-
-        Note: Daemon mode doesn't require explicit document open/close,
-        but we track this for compatibility.
-
-        Args:
-            file_path: Path to the file to open
-            wait_for_diagnostics: Unused in daemon mode (kept for interface compatibility)
-        """
-        # In daemon mode, documents are automatically loaded on demand
-        _ = wait_for_diagnostics  # Unused in daemon mode
-        return file_path.absolute().as_uri()
-
-    def close_document(self, uri: str) -> None:
-        """Close a document in the LSP server.
-
-        Note: Daemon mode doesn't require explicit document open/close.
-        """
-        # No-op for daemon mode
-
-    def request(self, method: str, params: Any = None, retry_on_timeout: bool = True) -> Any:
-        """Send a request and wait for response.
-
-        Args:
-            method: LSP method name
-            params: LSP method parameters
-            retry_on_timeout: Unused in daemon mode (daemon handles its own retries)
-
-        Returns:
-            LSP response result
-        """
-        _ = retry_on_timeout  # Daemon handles retries internally
-        try:
-            return self.daemon.lsp_request(method, params or {})
-        except Exception as exc:
-            if "ConnectionError" in str(exc) or "not running" in str(exc):
-                raise RuntimeError(f"Daemon not available: {exc}") from exc
-            raise
-
-    def request_with_timeout(self, method: str, params: Any = None, timeout: float = 5.0) -> Any:
-        """Send a request with a custom timeout.
-
-        Args:
-            method: LSP method name
-            params: LSP method parameters
-            timeout: Unused in daemon mode (daemon handles its own timeouts)
-
-        Returns:
-            LSP response result
-        """
-        _ = timeout  # Daemon handles its own timeouts
-        # Daemon client handles its own timeouts, so we just call the normal request
-        return self.request(method, params)