@ngocsangairvds/vsaf 3.2.14 → 3.2.16

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

@@ -1,3370 +0,0 @@
-"""CLI for LSP operations using Typer."""
-
-from __future__ import annotations
-
-import fnmatch
-import json
-import logging
-import subprocess
-import sys
-import time
-from datetime import UTC, datetime
-from pathlib import Path
-from typing import Annotated, Any, Literal, TypedDict, cast
-
-import typer
-
-from vds_cli_common import (
-    CLIContext,
-    ErrorHandler,
-    ExitCodes,
-    OutputManager,
-    create_version_callback,
-)
-
-from . import __version__
-from .core import (
-    add_type_ignore_comment,
-    batch_fix_all,
-    batch_format,
-    batch_organize_imports,
-    check_types,
-    completion,
-    daemon_restart,
-    daemon_start,
-    daemon_status,
-    daemon_stop,
-    document_highlight,
-    document_links,
-    find_references,
-    find_symbols,
-    fix_all,
-    format_document,
-    format_range,
-    get_callees,
-    get_callers,
-    get_code_actions,
-    get_diagnostics,
-    get_document_symbols,
-    go_to_definition,
-    go_to_implementation,
-    hover,
-    inlay_hints,
-    lsp_health,
-    organize_imports,
-    rename_symbol,
-    semantic_tokens,
-    signature_help,
-    suggest_imports,
-)
-from .formatters import CallGraphFormatter
-from .utils import _uri_to_path, load_config
-
-APP_NAME = "vds-lsp-orchestrator"
-
-
-class LspOverrides(TypedDict):
-    config_file: Path | None
-    lsp_server: str | None
-
-
-class PathFilters(TypedDict):
-    include: list[str]
-    exclude: list[str]
-    git_tracked: bool
-
-
-logger = logging.getLogger(__name__)
-
-
-VALID_COMMANDS = [
-    "symbol",
-    "type-check",
-    "diagnostics",
-    "refs",
-    "callers",
-    "callees",
-    "doc-symbols",
-    "doc-links",
-    "goto",
-    "implementations",
-    "fix-errors",
-    "rollback",
-    "code-actions",
-    "index-workspace",
-    "format",
-    "organize-imports",
-    "fix-all",
-    "hover",
-    "completion",
-    "rename",
-    "signature-help",
-    "inlay-hints",
-    "semantic-tokens",
-    "health",
-    "highlight",
-    "batch-format",
-    "batch-organize-imports",
-    "batch-fix-all",
-    "daemon",
-    "suggest-imports",
-    "ignore-comment",
-    "detect-tools",
-]
-
-app = typer.Typer(
-    name="vds-lsp",
-    help="Language Server Protocol operations for Python projects",
-    rich_markup_mode="rich",
-    invoke_without_command=True,
-    no_args_is_help=False,
-)
-
-version_callback = create_version_callback(APP_NAME)
-
-
-def _get_state(
-    ctx: typer.Context,
-) -> tuple[
-    CLIContext,
-    OutputManager,
-    ErrorHandler,
-    Any,
-    LspOverrides,
-    PathFilters,
-    Path | None,
-    bool,
-]:
-    default_overrides: LspOverrides = {"config_file": None, "lsp_server": None}
-    default_filters: PathFilters = {"include": [], "exclude": [], "git_tracked": False}
-    if not isinstance(ctx.obj, dict):
-        cli_ctx = CLIContext()
-        output = OutputManager(cli_ctx)
-        error_handler = ErrorHandler(output, valid_commands=VALID_COMMANDS)
-        config = load_config(Path.cwd())
-        return (
-            cli_ctx,
-            output,
-            error_handler,
-            config,
-            default_overrides,
-            default_filters,
-            None,
-            False,
-        )
-    overrides = cast("LspOverrides", ctx.obj.get("lsp_config", default_overrides))
-    filters = cast("PathFilters", ctx.obj.get("path_filters", default_filters))
-    return (
-        ctx.obj["cli_ctx"],
-        ctx.obj["output"],
-        ctx.obj["error_handler"],
-        ctx.obj["config"],
-        overrides,
-        filters,
-        ctx.obj.get("output_file"),
-        ctx.obj.get("verbose", False),
-    )
-
-
-def _build_meta() -> dict[str, Any]:
-    return {
-        "timestamp": datetime.now(UTC).isoformat(),
-        "tool": {"name": APP_NAME, "version": __version__},
-        "python": sys.version.split()[0],
-        "cwd": str(Path.cwd()),
-    }
-
-
-def _add_meta(payload: Any) -> dict[str, Any]:
-    meta = _build_meta()
-    if isinstance(payload, dict):
-        if "meta" in payload:
-            return payload
-        return {**payload, "meta": meta}
-    return {"data": payload, "meta": meta}
-
-
-def _emit_json(output: OutputManager, payload: Any) -> None:
-    output.output_json(_add_meta(payload))
-
-
-def _write_output_file(path: Path, payload: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    _ = path.write_text(json.dumps(_add_meta(payload), indent=2, default=str))
-
-
-def _git_root(start: Path) -> Path | None:
-    try:
-        result = subprocess.run(
-            ["git", "-C", str(start), "rev-parse", "--show-toplevel"],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-    except FileNotFoundError:
-        return None
-    if result.returncode != 0:
-        return None
-    return Path(result.stdout.strip())
-
-
-def _git_tracked_files(root: Path) -> list[Path]:
-    result = subprocess.run(
-        ["git", "-C", str(root), "ls-files"],
-        capture_output=True,
-        text=True,
-        check=False,
-    )
-    if result.returncode != 0:
-        return []
-    return [root / line.strip() for line in result.stdout.splitlines() if line.strip()]
-
-
-def _filter_paths(
-    *,
-    paths: list[Path] | None,
-    filters: PathFilters,
-    allow_notebooks: bool = True,
-    output: OutputManager | None = None,
-) -> list[Path]:
-    if not paths:
-        paths = [Path.cwd()]
-
-    include = filters.get("include", [])
-    exclude = filters.get("exclude", [])
-    git_tracked = filters.get("git_tracked", False)
-
-    if not include and not exclude and not git_tracked:
-        return paths
-
-    roots = [p if p.is_absolute() else Path.cwd() / p for p in paths]
-    base_root = _git_root(roots[0]) if git_tracked else roots[0]
-
-    candidates: list[Path] = []  # Initialize to avoid "possibly unbound" error
-    if git_tracked:
-        if base_root is None:
-            if output:
-                output.output_warning(
-                    "git-tracked requested but no git repo found; falling back to filesystem scan"
-                )
-            git_tracked = False
-        elif allow_notebooks:
-            candidates = [p for p in _git_tracked_files(base_root) if p.suffix in {".py", ".ipynb"}]
-        else:
-            candidates = [p for p in _git_tracked_files(base_root) if p.suffix == ".py"]
-    if not git_tracked:
-        for root in roots:
-            if root.is_dir():
-                candidates.extend(root.rglob("*.py"))
-                if allow_notebooks:
-                    candidates.extend(root.rglob("*.ipynb"))
-            else:
-                candidates.append(root)
-
-    base_root = base_root or roots[0]
-    filtered: list[Path] = []
-    for path in candidates:
-        try:
-            rel = path.relative_to(base_root).as_posix()
-        except ValueError:
-            rel = path.as_posix()
-        if include and not any(fnmatch.fnmatch(rel, pattern) for pattern in include):
-            continue
-        if exclude and any(fnmatch.fnmatch(rel, pattern) for pattern in exclude):
-            continue
-        filtered.append(path)
-
-    if not filtered and output:
-        output.output_warning("No files matched include/exclude filters")
-    return filtered
-
-
-@app.callback(invoke_without_command=True)
-def callback(
-    ctx: typer.Context,
-    _version: Annotated[
-        bool,
-        typer.Option(
-            "--version",
-            "-V",
-            callback=version_callback,
-            is_eager=True,
-            help="Show version and exit",
-        ),
-    ] = False,
-    json_only: Annotated[
-        bool,
-        typer.Option(
-            "--json-only",
-            "-j",
-            help="Output clean JSON only",
-        ),
-    ] = False,
-    quiet: Annotated[
-        bool,
-        typer.Option(
-            "--quiet",
-            "-q",
-            help="Suppress non-essential output",
-        ),
-    ] = False,
-    verbose: Annotated[
-        bool,
-        typer.Option(
-            "--verbose",
-            "-v",
-            help="Enable verbose output",
-        ),
-    ] = False,
-    no_color: Annotated[
-        bool,
-        typer.Option(
-            "--no-color",
-            help="Disable colored output",
-        ),
-    ] = False,
-    color: Annotated[
-        bool,
-        typer.Option(
-            "--color",
-            help="Force colored output",
-        ),
-    ] = False,
-    output_file: Annotated[
-        Path | None,
-        typer.Option(
-            "--output",
-            help="Write JSON output to a file",
-        ),
-    ] = None,
-    include: Annotated[
-        list[str] | None,
-        typer.Option(
-            "--include",
-            "-i",
-            help="Only include files matching glob patterns",
-        ),
-    ] = None,
-    exclude: Annotated[
-        list[str] | None,
-        typer.Option(
-            "--exclude",
-            "-x",
-            help="Exclude files matching glob patterns",
-        ),
-    ] = None,
-    git_tracked: Annotated[
-        bool,
-        typer.Option(
-            "--git-tracked",
-            help="Restrict to git-tracked files",
-        ),
-    ] = False,
-    lsp_server: Annotated[
-        str | None,
-        typer.Option(
-            "--lsp-server",
-            help="Override LSP server command (e.g., basedpyright-langserver)",
-        ),
-    ] = None,
-    config_file: Annotated[
-        Path | None,
-        typer.Option(
-            "--config-file",
-            help="Override pyright config file (pyrightconfig.json or .basedpyright)",
-            exists=True,
-            dir_okay=False,
-            readable=True,
-        ),
-    ] = None,
-    wsl_optimize: Annotated[
-        bool,
-        typer.Option(
-            "--wsl-optimize/--no-wsl-optimize",
-            help="Enable WSL2 filesystem optimization (auto-detected by default)",
-        ),
-    ] = False,
-    docker: Annotated[
-        bool,
-        typer.Option(
-            "--docker",
-            help="Run LSP server in Docker container for isolated, reproducible environment",
-        ),
-    ] = False,
-) -> None:
-    cli_ctx = CLIContext.from_options(
-        json_only=json_only,
-        quiet=quiet,
-        no_color=no_color,
-        force_color=color,
-    )
-    if verbose:
-        logging.basicConfig(level=logging.DEBUG)
-    output = OutputManager(cli_ctx)
-    error_handler = ErrorHandler(output, valid_commands=VALID_COMMANDS)
-    config = load_config(Path.cwd(), config_file=config_file, lsp_server=lsp_server)
-
-    # Override wsl_optimize from CLI flag if explicitly set
-    if wsl_optimize:
-        config.wsl_optimize = True
-    elif ctx.params.get("no_wsl_optimize", False):
-        config.wsl_optimize = False
-
-    # Apply Docker mode from CLI flag
-    if docker:
-        config.docker_mode = True
-        if not verbose:
-            output.ctx.console.print(
-                "[cyan]Docker mode enabled[/cyan] - LSP server will run in container"
-            )
-
-    ctx.obj = {
-        "cli_ctx": cli_ctx,
-        "output": output,
-        "error_handler": error_handler,
-        "config": config,
-        "output_file": output_file,
-        "verbose": verbose,
-        "path_filters": {
-            "include": include or [],
-            "exclude": exclude or [],
-            "git_tracked": git_tracked,
-        },
-        "lsp_config": {
-            "config_file": config_file,
-            "lsp_server": lsp_server,
-        },
-    }
-
-    if ctx.invoked_subcommand is None:
-        output.ctx.console.print(ctx.get_help())
-        raise typer.Exit(ExitCodes.SUCCESS)
-
-
-@app.command("symbol")
-def symbol_cmd(
-    ctx: typer.Context,
-    query: Annotated[str, typer.Argument(help="Symbol name or pattern to search")],
-    kind: Annotated[
-        str | None,
-        typer.Option("--kind", "-k", help="Filter by symbol kind (class, function, method)"),
-    ] = None,
-    match: Annotated[
-        str,
-        typer.Option(
-            "--match",
-            help="Match mode: contains, exact, regex",
-        ),
-    ] = "contains",
-    limit: Annotated[
-        int,
-        typer.Option("--limit", "-l", help="Maximum number of results (0 for no limit)"),
-    ] = 50,
-    path: Annotated[
-        Path | None,
-        typer.Option("--path", "-p", help="Path to search (default: current directory)"),
-    ] = None,
-) -> None:
-    """Search for symbols in the workspace."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    search_path = path or Path.cwd()
-    if search_path.is_file():
-        search_path = search_path.parent
-
-    results: list[dict[str, Any]] = []  # Initialize to avoid "possibly unbound" error
-    try:
-        results = find_symbols(search_path, query, kind, match=match, limit=limit, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to search for symbols",
-            details={"error": str(exc)},
-        )
-        return  # Exit early if symbol search fails
-
-    if (
-        path_filters.get("include")
-        or path_filters.get("exclude")
-        or path_filters.get("git_tracked")
-    ):
-        allowed = _filter_paths(
-            paths=[search_path],
-            filters=path_filters,
-            allow_notebooks=config.notebook_support,
-            output=output,
-        )
-        allowed_rel = set()
-        for allowed_path in allowed:
-            allowed_rel.add(allowed_path.as_posix())
-            try:
-                allowed_rel.add(allowed_path.relative_to(search_path).as_posix())
-            except ValueError:
-                continue
-        results = [sym for sym in results if sym.get("location", {}).get("file") in allowed_rel]
-
-    if output_file:
-        _write_output_file(output_file, {"symbols": results})
-
-    if cli_ctx.json_only:
-        _emit_json(output, {"symbols": results})
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        table = Table(title=f"Symbols matching '{query}'")
-        table.add_column("Name", style="cyan")
-        table.add_column("Kind", style="green")
-        table.add_column("Location", style="yellow")
-
-        for sym in results:
-            loc = sym["location"]
-            table.add_row(sym["name"], sym["kind"], f"{loc['file']}:{loc['line']}")
-        output.ctx.console.print(table)
-
-
-@app.command("diagnostics")
-def diagnostics_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path] | None,
-        typer.Argument(..., help="Paths to check"),
-    ] = None,
-    include_warnings: Annotated[
-        bool,
-        typer.Option("--warnings", "-w", help="Include warnings in output"),
-    ] = False,
-    fixable: Annotated[
-        bool,
-        typer.Option("--fixable", help="Annotate diagnostics with available code actions"),
-    ] = False,
-    max_fixable: Annotated[
-        int | None,
-        typer.Option("--max-fixable", help="Limit number of diagnostics to scan for fixes"),
-    ] = 50,
-    severity: Annotated[
-        list[str] | None,
-        typer.Option("--severity", "-s", help="Filter by severity (error, warning, info, hint)"),
-    ] = None,
-    code: Annotated[
-        list[str] | None,
-        typer.Option("--code", help="Filter by diagnostic code"),
-    ] = None,
-    file: Annotated[
-        list[str] | None,
-        typer.Option("--file", help="Filter by file glob pattern"),
-    ] = None,
-    watch: Annotated[
-        bool,
-        typer.Option("--watch", help="Watch files and rerun diagnostics on changes"),
-    ] = False,
-    interval: Annotated[
-        float,
-        typer.Option("--interval", help="Polling interval (seconds) for watch mode"),
-    ] = 2.0,
-) -> None:
-    """Get diagnostics for specified paths."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    check_paths = _filter_paths(
-        paths=paths, filters=path_filters, allow_notebooks=config.notebook_support, output=output
-    )
-    if not check_paths:
-        diagnostics = {
-            "diagnostics": [],
-            "summary": {
-                "total_errors": 0,
-                "total_warnings": 0,
-                "total_info": 0,
-                "by_category": {},
-                "by_source": {},
-            },
-            "sources": [],
-        }
-        if output_file:
-            _write_output_file(output_file, diagnostics)
-        if cli_ctx.json_only:
-            _emit_json(output, diagnostics)
-        return
-
-    if severity:
-        include_warnings = include_warnings or any(
-            level.lower() in {"warning", "info", "hint"} for level in severity
-        )
-
-    def filter_diagnostics(payload: dict[str, Any]) -> dict[str, Any]:
-        diags = payload.get("diagnostics", [])
-        filtered = []
-        severity_filter = [s.lower() for s in severity or []]
-        code_filter = set(code or [])
-        file_patterns = file or []
-
-        for diag in diags:
-            if severity_filter and diag.get("severity", "").lower() not in severity_filter:
-                continue
-            if code_filter and diag.get("code") not in code_filter:
-                continue
-            if file_patterns:
-                file_path = diag.get("file") or ""
-                if not any(fnmatch.fnmatch(file_path, pattern) for pattern in file_patterns):
-                    continue
-            filtered.append(diag)
-
-        summary: dict[str, Any] = {
-            "total_errors": 0,
-            "total_warnings": 0,
-            "total_info": 0,
-            "by_category": {},
-            "by_source": {},
-        }
-        for diag in filtered:
-            sev = diag.get("severity")
-            if sev == "error":
-                summary["total_errors"] += 1
-            elif sev == "warning":
-                summary["total_warnings"] += 1
-            elif sev == "info":
-                summary["total_info"] += 1
-            category = diag.get("category", "general")
-            summary["by_category"][category] = summary["by_category"].get(category, 0) + 1
-            src = diag.get("source", "unknown")
-            summary["by_source"][src] = summary["by_source"].get(src, 0) + 1
-
-        return {**payload, "diagnostics": filtered, "summary": summary}
-
-    def run_once() -> dict[str, Any]:
-        try:
-            payload = get_diagnostics(
-                check_paths,
-                include_warnings,
-                include_fixable=fixable,
-                max_fixable=max_fixable,
-                **lsp_config,
-            )
-        except Exception as exc:
-            error_handler.handle_general_error(
-                "Failed to get diagnostics",
-                details={"error": str(exc)},
-            )
-            # Return empty result structure on error
-            return {
-                "diagnostics": [],
-                "summary": {
-                    "total_errors": 0,
-                    "total_warnings": 0,
-                    "total_info": 0,
-                    "by_category": {},
-                    "by_source": {},
-                },
-            }
-        return filter_diagnostics(payload)
-
-    if watch:
-        output.ctx.console.print("[bold]Watching for changes...[/bold]")
-        last_mtimes: dict[Path, float] = {}
-        try:
-            while True:
-                changed = False
-                for path in check_paths:
-                    try:
-                        mtime = path.stat().st_mtime
-                    except FileNotFoundError:
-                        mtime = 0.0
-                    if last_mtimes.get(path) != mtime:
-                        changed = True
-                    last_mtimes[path] = mtime
-
-                if changed or not last_mtimes:
-                    if not cli_ctx.quiet and not cli_ctx.json_only:
-                        output.ctx.console.print("[dim]Running diagnostics...[/dim]")
-                    diagnostics = run_once()
-                    if output_file:
-                        _write_output_file(output_file, diagnostics)
-                    if cli_ctx.json_only:
-                        _emit_json(output, diagnostics)
-                    elif not cli_ctx.quiet:
-                        from rich.table import (
-                            Table,
-                        )
-
-                        diags = diagnostics.get("diagnostics", [])
-                        table = Table(title="Diagnostics")
-                        table.add_column("File", style="cyan")
-                        table.add_column("Severity", style="magenta")
-                        table.add_column("Message", style="white")
-                        table.add_column("Category", style="green")
-                        table.add_column("Source", style="dim")
-                        if fixable:
-                            table.add_column("Fixable", style="green")
-
-                        for diag in diags:
-                            file_path = diag.get("file", "unknown")
-                            msg = diag.get("message", "Unknown error")
-                            sev = diag.get("severity", "error")
-                            row = [
-                                str(file_path),
-                                sev,
-                                msg,
-                                diag.get("category", "general"),
-                                diag.get("source", "unknown"),
-                            ]
-                            if fixable:
-                                row.append("yes" if diag.get("fixable") else "no")
-                            table.add_row(*row)
-
-                        output.ctx.console.print(table)
-
-                time.sleep(interval)
-        except KeyboardInterrupt:
-            output.ctx.console.print("[yellow]Stopped watch mode.[/yellow]")
-        return
-
-    diagnostics = run_once()
-
-    if output_file:
-        _write_output_file(output_file, diagnostics)
-
-    if cli_ctx.json_only:
-        _emit_json(output, diagnostics)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        diags = diagnostics.get("diagnostics", [])
-        table = Table(title="Diagnostics")
-        table.add_column("File", style="cyan")
-        table.add_column("Severity", style="magenta")
-        table.add_column("Message", style="white")
-        table.add_column("Category", style="green")
-        table.add_column("Source", style="dim")
-        if fixable:
-            table.add_column("Fixable", style="green")
-
-        for diag in diags:
-            file_path = diag.get("file", "unknown")
-            # Handle both formats (basedpyright raw or normalized)
-            # If normalized by BasedPyrightRunner, it might have line info
-
-            # Simple fallback display
-            msg = diag.get("message", "Unknown error")
-            severity = diag.get("severity", "error")
-
-            row = [
-                str(file_path),
-                severity,
-                msg,
-                diag.get("category", "general") or "general",
-                diag.get("source", "unknown") or "unknown",
-            ]
-            if fixable:
-                row.append("yes" if diag.get("fixable") else "no")
-            table.add_row(*row)  # pyright: ignore[reportArgumentType]
-
-        output.ctx.console.print(table)
-
-
-@app.command("type-check")
-def type_check_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path],
-        typer.Argument(..., help="Paths to type check"),
-    ],
-    mode: Annotated[
-        str,
-        typer.Option("--mode", "-m", help="Type checking mode (basic, standard, strict)"),
-    ] = "standard",
-    fix: Annotated[
-        bool,
-        typer.Option("--fix", "-f", help="Auto-fix applicable issues"),
-    ] = False,
-    type_checker: Annotated[
-        str,
-        typer.Option(
-            "--type-checker",
-            "-t",
-            help="Type checker to use (auto, mypy, basedpyright, pyright, pylsp)",
-        ),
-    ] = "auto",
-    dry_run: Annotated[
-        bool,
-        typer.Option("--dry-run", help="Show what would be checked without running"),
-    ] = False,
-) -> None:
-    """Run type checking on specified paths."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    check_paths = _filter_paths(
-        paths=paths, filters=path_filters, allow_notebooks=config.notebook_support, output=output
-    )
-    if not check_paths:
-        result = {"summary": "No paths matched filters", "diagnostics": []}
-        if output_file:
-            _write_output_file(output_file, result)
-        if cli_ctx.json_only:
-            _emit_json(output, result)
-        return
-
-    # Handle dry-run mode
-    if dry_run:
-        dry_run_info = {
-            "paths": [str(p) for p in check_paths],
-            "type_checker": type_checker,
-            "mode": mode,
-            "fix": fix,
-        }
-        if output_file:
-            _write_output_file(output_file, {"dry_run": True, **dry_run_info})
-        if cli_ctx.json_only:
-            _emit_json(output, {"dry_run": True, **dry_run_info})
-        elif not cli_ctx.quiet:
-            output.ctx.console.print(
-                f"[yellow]Would check:[/yellow] {', '.join(str(p) for p in check_paths)}"
-            )
-            output.ctx.console.print(f"[cyan]Type checker:[/cyan] {type_checker}")
-            output.ctx.console.print(f"[cyan]Mode:[/cyan] {mode}")
-        return
-
-    result: dict[str, Any] = {}  # Initialize to avoid "possibly unbound" error
-    try:
-        result = check_types(check_paths, mode, fix, type_checker=type_checker, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Type checking failed",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        diagnostics_data = result.get("diagnostics", [])
-
-        output.ctx.console.print("[bold]Type Check Results[/bold]")
-
-        if diagnostics_data:
-            table = Table(title=f"Diagnostics ({len(diagnostics_data)})")
-            table.add_column("File", style="cyan")
-            table.add_column("Severity", style="magenta")
-            table.add_column("Message", style="white")
-            table.add_column("Rule", style="dim")
-
-            for diag in diagnostics_data:
-                file_path = diag.get("file", "unknown")
-                range_start = diag.get("range", {}).get("start", {})
-                line = range_start.get("line", 0) + 1
-                col = range_start.get("character", 0) + 1
-
-                table.add_row(
-                    f"{file_path}:{line}:{col}",
-                    diag.get("severity", "unknown"),
-                    diag.get("message", ""),
-                    diag.get("rule", ""),
-                )
-            output.ctx.console.print(table)
-        else:
-            output.ctx.console.print("[green]No issues found![/green]")
-
-        if "error" in result:
-            output.ctx.console.print(f"[red]Error: {result['error']}[/red]")
-
-
-@app.command("doc-symbols")
-def doc_symbols_cmd(
-    ctx: typer.Context,
-    file: Annotated[
-        Path,
-        typer.Argument(..., help="File to analyze"),
-    ],
-) -> None:
-    """Get document symbols for a file."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    symbols_result: dict[str, Any] = {
-        "symbols": [],
-        "source": "unknown",
-    }  # Initialize to avoid "possibly unbound"
-    try:
-        symbols_result = get_document_symbols(file, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to get document symbols",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, symbols_result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, symbols_result)
-    elif not cli_ctx.quiet:
-        from rich.tree import Tree
-
-        symbols = symbols_result.get("symbols", [])
-        src = symbols_result.get("source", "unknown")
-
-        tree = Tree(f"Symbols in {file} (Source: {src})")
-
-        # Helper to recursively build tree (if LSP returns hierarchy)
-        def build_tree(nodes, parent_tree):
-            for node in nodes:
-                # Handle both LSP and AST formats
-                name = node.get("name", "unknown")
-                kind = node.get("kind", "unknown")
-
-                branch = parent_tree.add(f"[cyan]{name}[/cyan] [dim]({kind})[/dim]")
-
-                if "children" in node:
-                    build_tree(node["children"], branch)
-
-        build_tree(symbols, tree)
-        output.ctx.console.print(tree)
-
-
-@app.command("goto")
-def goto_cmd(
-    ctx: typer.Context,
-    symbol: Annotated[str, typer.Argument(help="Symbol to go to definition for")],
-    file: Annotated[
-        str | None,
-        typer.Option("--file", "-f", help="File location for disambiguation (path:line:col)"),
-    ] = None,
-) -> None:
-    """Go to definition of a symbol.
-
-    Supports:
-    - Symbol definitions (functions, classes, variables)
-    - Operator definitions (goes to dunder method like __add__, __mul__, etc.)
-
-    For operators, use --file with the operator position:
-        vds-lsp goto --file "myfile.py:10:8" "__add__"
-    """
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    location: dict[str, Any] = {"locations": []}  # Initialize to avoid "possibly unbound"
-    try:
-        location = go_to_definition(symbol, file, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to go to definition",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, location)
-
-    if cli_ctx.json_only:
-        _emit_json(output, location)
-    elif not cli_ctx.quiet:
-        from rich.panel import Panel
-
-        output.ctx.console.print(Panel(str(location), title="Definition Locations"))
-
-
-@app.command("implementations")
-def implementations_cmd(
-    ctx: typer.Context,
-    location: Annotated[
-        str,
-        typer.Argument(..., help="Location in format file:line:col"),
-    ],
-) -> None:
-    """Go to implementations of the symbol at the given location."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    result: dict[str, Any] = {
-        "locations": [],
-        "source": "unknown",
-        "message": "",
-    }  # Initialize to avoid "possibly unbound"
-    try:
-        result = go_to_implementation(location, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to find implementations",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        locations = result.get("locations", [])
-        source = result.get("source", "unknown")
-        message = result.get("message", "")
-
-        table = Table(title=f"Implementations at {location} (Source: {source})")
-        table.add_column("File", style="cyan")
-        table.add_column("Line", style="green")
-        table.add_column("Column", style="blue")
-
-        for loc in locations:
-            if isinstance(loc, dict):
-                uri = loc.get("uri", "")
-                range_info = loc.get("range", {})
-                if uri:
-                    file_path = _uri_to_path(uri)
-                    start = range_info.get("start", {})
-                    line = start.get("line", 0) + 1
-                    col = start.get("character", 0) + 1
-                    table.add_row(str(file_path), str(line), str(col))
-
-        output.ctx.console.print(table)
-        if message:
-            output.ctx.console.print(f"[dim]{message}[/dim]")
-
-
-@app.command("highlight")
-def highlight_cmd(
-    ctx: typer.Context,
-    location: Annotated[
-        str,
-        typer.Argument(..., help="Location in format file:line:col"),
-    ],
-) -> None:
-    """Highlight all references to the symbol at the given location in the current file."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    result: dict[str, Any] = {
-        "highlights": [],
-        "source": "unknown",
-    }  # Initialize to avoid "possibly unbound"
-    try:
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-
-        result = document_highlight(file_path, line, col, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to get document highlights",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        highlights = result.get("highlights", [])
-        src = result.get("source", "unknown")
-
-        table = Table(title=f"Document Highlights at {location} (Source: {src})")
-        table.add_column("Line", style="cyan")
-        table.add_column("Column", style="magenta")
-        table.add_column("End Line", style="cyan")
-        table.add_column("End Column", style="magenta")
-        table.add_column("Kind", style="green")
-
-        for hl in highlights:
-            range_info = hl.get("range", {})
-            start = range_info.get("start", {})
-            end = range_info.get("end", {})
-            kind = hl.get("kind_name", "Unknown")
-            table.add_row(
-                str(start.get("line", 0)),
-                str(start.get("character", 0)),
-                str(end.get("line", 0)),
-                str(end.get("character", 0)),
-                kind,
-            )
-
-        output.ctx.console.print(table)
-
-
-@app.command("doc-links")
-def doc_links_cmd(
-    ctx: typer.Context,
-    file: Annotated[
-        str,
-        typer.Argument(..., help="Path to the file to analyze for links"),
-    ],
-) -> None:
-    """Find all clickable links in a document (URLs, imports, file references)."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    result: dict[str, Any] = {
-        "links": [],
-        "source": "unknown",
-    }  # Initialize to avoid "possibly unbound"
-    try:
-        result = document_links(file, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to get document links",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        links = result.get("links", [])
-        src = result.get("source", "unknown")
-        message = result.get("message", "")
-
-        table = Table(title=f"Document Links in {file} (Source: {src})")
-        table.add_column("Line", style="cyan")
-        table.add_column("Start Col", style="magenta")
-        table.add_column("End Col", style="magenta")
-        table.add_column("Target", style="green")
-        table.add_column("Kind", style="yellow")
-
-        for link in links:
-            range_info = link.get("range", {})
-            start = range_info.get("start", {})
-            end = range_info.get("end", {})
-            target = link.get("target", "")
-            kind = link.get("kind", link.get("tooltip", ""))
-
-            table.add_row(
-                str(start.get("line", 0)),
-                str(start.get("character", 0)),
-                str(end.get("character", 0)),
-                target[:80] if target else "",  # Truncate long targets
-                kind,
-            )
-
-        output.ctx.console.print(table)
-        if message:
-            output.ctx.console.print(f"[dim]{message}[/dim]")
-
-
-@app.command("refs")
-def refs_cmd(
-    ctx: typer.Context,
-    symbol: Annotated[str, typer.Argument(help="Symbol to find references for")],
-    file: Annotated[
-        str | None,
-        typer.Option("--file", "-f", help="File location for disambiguation (path:line:col)"),
-    ] = None,
-    context_lines: Annotated[
-        int,
-        typer.Option("--context", "-c", help="Number of context lines to include"),
-    ] = 0,
-) -> None:
-    """Find all references to a symbol."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    references: dict[str, Any] = {"references": []}  # Initialize to avoid "possibly unbound"
-    try:
-        references = find_references(symbol, file, context_lines=context_lines, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to find references",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if (
-        path_filters.get("include")
-        or path_filters.get("exclude")
-        or path_filters.get("git_tracked")
-    ):
-        allowed = _filter_paths(
-            paths=[Path.cwd()],
-            filters=path_filters,
-            allow_notebooks=config.notebook_support,
-            output=output,
-        )
-        allowed_rel = set()
-        for allowed_path in allowed:
-            allowed_rel.add(allowed_path.as_posix())
-            try:
-                allowed_rel.add(allowed_path.relative_to(Path.cwd()).as_posix())
-            except ValueError:
-                continue
-        filtered_refs: list[dict[str, Any]] = []
-        for ref in references.get("references", []):
-            if "location" in ref:
-                if ref["location"].get("file") in allowed_rel:
-                    filtered_refs.append(ref)
-            elif "uri" in ref:
-                uri_val = ref.get("uri")
-                if not uri_val:
-                    continue
-                rel = uri_val.replace("file://", "")
-                if rel in allowed_rel:
-                    filtered_refs.append(ref)
-        references = {**references, "references": filtered_refs}
-
-    if output_file:
-        _write_output_file(output_file, references)
-
-    if cli_ctx.json_only:
-        _emit_json(output, references)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        refs_list = references.get("references", [])
-        src = references.get("source", "unknown")
-
-        table = Table(title=f"References to '{symbol}' (Source: {src})")
-        table.add_column("Location", style="cyan")
-        table.add_column("Line", style="magenta")
-        table.add_column("Category", style="green")
-        if context_lines > 0:
-            table.add_column("Context", style="white")
-
-        for ref in refs_list:
-            if "location" in ref:  # AST format
-                loc = ref["location"]
-                row = [loc["file"], str(loc["line"]), ref.get("category", "reference")]
-                if context_lines > 0:
-                    context = ref.get("context", {})
-                    row.append(context.get("line_text", ""))
-                table.add_row(*row)
-            elif "uri" in ref:  # LSP format
-                uri_value = ref.get("uri")
-                if not uri_value:
-                    continue
-                uri = uri_value.replace("file://", "")
-                line = ref["range"]["start"]["line"] + 1
-                row = [uri, str(line), ref.get("category", "reference")]
-                if context_lines > 0:
-                    context = ref.get("context", {})
-                    row.append(context.get("line_text", ""))
-                table.add_row(*row)
-
-        output.ctx.console.print(table)
-
-
-@app.command("fix-errors")
-def fix_errors_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path],
-        typer.Argument(..., help="Paths to fix"),
-    ],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply fixes to files"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying fixes"),
-    ] = False,
-    max_actions: Annotated[
-        int | None,
-        typer.Option("--max-actions", help="Limit number of actions applied"),
-    ] = None,
-    kinds: Annotated[
-        list[str] | None,
-        typer.Option(
-            "--kinds",
-            help="Limit code actions by kind prefix (e.g. quickfix, refactor, source.organizeImports)",
-        ),
-    ] = None,
-    confirm_annotations: Annotated[
-        bool,
-        typer.Option("--confirm-annotations", help="Allow edits that require change annotations"),
-    ] = False,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-    patch_file: Annotated[
-        Path | None,
-        typer.Option("--patch-file", help="Write unified diff output to a file"),
-    ] = None,
-) -> None:
-    """Auto-fix errors in specified paths."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    check_paths = _filter_paths(
-        paths=paths, filters=path_filters, allow_notebooks=config.notebook_support, output=output
-    )
-    if not check_paths:
-        result = {"message": "No paths matched filters.", "fixed_count": 0, "actions_available": 0}
-        if output_file:
-            _write_output_file(output_file, result)
-        if cli_ctx.json_only:
-            _emit_json(output, result)
-        return
-
-    try:
-        from .core import fix_errors
-
-        if apply and not yes:
-            if cli_ctx.json_only:
-                error_handler.handle_general_error(
-                    "Apply requires confirmation",
-                    details={"message": "Use --yes to confirm applying fixes."},
-                )
-                return
-            confirm = typer.confirm("Apply fixes to files?")
-            if not confirm:
-                output.output_warning("Aborted applying fixes.")
-                return
-
-        result = fix_errors(
-            check_paths,
-            apply=apply,
-            max_actions=max_actions,
-            allow_kinds=kinds,
-            confirm_annotations=confirm_annotations,
-            **lsp_config,
-        )
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to fix errors",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if patch_file and not apply:
-        patch_text = result.get("patch") or ""
-        if patch_text.strip():
-            patch_file.parent.mkdir(parents=True, exist_ok=True)
-            _ = patch_file.write_text(patch_text)
-        elif not cli_ctx.quiet and not cli_ctx.json_only:
-            output.ctx.console.print("[yellow]No patch content to write.[/yellow]")
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "Operation complete"))
-
-        if apply:
-            fixed = result.get("fixed_count", 0)
-            if fixed > 0:
-                output.ctx.console.print(f"[green]Applied {fixed} fixes[/green]")
-            if result.get("backup_dir"):
-                output.ctx.console.print(f"Backup: {result['backup_dir']}")
-            if result.get("skipped_needs_confirmation"):
-                output.ctx.console.print(
-                    "[yellow]Some actions were skipped due to required change annotations. "
-                    "Re-run with --confirm-annotations to apply them.[/yellow]",
-                )
-            if patch_file:
-                output.ctx.console.print(
-                    "[yellow]Patch file output is only available for preview mode (no --apply).[/yellow]",
-                )
-        else:
-            previews = result.get("previews", [])
-            if previews:
-                import difflib
-
-                for i, preview in enumerate(previews):
-                    if i >= max_previews:
-                        break
-                    if "command" in preview and "before" not in preview:
-                        output.ctx.console.print(
-                            f"[cyan]{preview.get('title', 'Command')}[/cyan]: {preview['command']}",
-                        )
-                        continue
-                    if preview.get("needs_confirmation"):
-                        output.ctx.console.print(
-                            "[yellow]Action requires confirmation via change annotations. "
-                            "Use --confirm-annotations to apply.[/yellow]",
-                        )
-                    before = preview.get("before", "").splitlines(keepends=True)
-                    after = preview.get("after", "").splitlines(keepends=True)
-                    path = preview.get("file", "unknown")
-                    diff = difflib.unified_diff(
-                        before,
-                        after,
-                        fromfile=f"{path}:before",
-                        tofile=f"{path}:after",
-                    )
-                    output.ctx.console.print("".join(diff))
-
-                if len(previews) > max_previews:
-                    output.ctx.console.print(
-                        f"[yellow]Showing {max_previews} of {len(previews)} previews. Use --json-only for full output.[/yellow]",
-                    )
-            if patch_file and (result.get("patch") or "").strip():
-                output.ctx.console.print(f"[green]Wrote patch file: {patch_file}[/green]")
-
-
-@app.command("rollback")
-def rollback_cmd(
-    ctx: typer.Context,
-    backup_dir: Annotated[
-        Path,
-        typer.Argument(..., help="Backup directory created by fix-errors"),
-    ],
-    root: Annotated[
-        Path | None,
-        typer.Option("--root", help="Root directory to restore into (default: cwd)"),
-    ] = None,
-) -> None:
-    """Rollback applied fixes from a backup directory."""
-    cli_ctx, output, error_handler, _, _lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        from .core import rollback_fixes
-
-        result = rollback_fixes(backup_dir, root=root)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to rollback fixes",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "Rollback complete"))
-        restored = result.get("restored", 0)
-        if restored:
-            output.ctx.console.print(f"[green]Restored {restored} files[/green]")
-
-
-@app.command("callers")
-def callers_cmd(
-    ctx: typer.Context,
-    symbol: Annotated[str, typer.Argument(help="Symbol to find incoming calls for")],
-    format: Annotated[
-        str,
-        typer.Option("--format", "-f", help="Output format: table, mermaid, plantuml"),
-    ] = "table",
-    max_depth: Annotated[
-        int,
-        typer.Option("--max-depth", help="Maximum call depth to traverse"),
-    ] = 1,
-    include_external: Annotated[
-        bool,
-        typer.Option("--include-external", help="Include calls outside the workspace"),
-    ] = False,
-    show_path: Annotated[
-        bool,
-        typer.Option("--show-path", help="Show call chain path"),
-    ] = False,
-) -> None:
-    """Find all incoming calls to a symbol (callers)."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        callers = get_callers(symbol, max_depth=max_depth, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to find callers",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if not include_external:
-        callers = {
-            **callers,
-            "callers": [c for c in callers.get("callers", []) if not c.get("external")],
-        }
-
-    if (
-        path_filters.get("include")
-        or path_filters.get("exclude")
-        or path_filters.get("git_tracked")
-    ):
-        allowed = _filter_paths(
-            paths=[Path.cwd()],
-            filters=path_filters,
-            allow_notebooks=config.notebook_support,
-            output=output,
-        )
-        allowed_rel = set()
-        for allowed_path in allowed:
-            allowed_rel.add(allowed_path.as_posix())
-            try:
-                allowed_rel.add(allowed_path.relative_to(Path.cwd()).as_posix())
-            except ValueError:
-                continue
-        callers = {
-            **callers,
-            "callers": [
-                c
-                for c in callers.get("callers", [])
-                if c.get("location", {}).get("file") in allowed_rel
-            ],
-        }
-
-    diagram_text = None
-    if format == "mermaid":
-        diagram_text = CallGraphFormatter.to_mermaid(symbol, callers.get("callers", []), "incoming")
-    elif format == "plantuml":
-        diagram_text = CallGraphFormatter.to_plantuml(
-            symbol, callers.get("callers", []), "incoming"
-        )
-
-    if output_file and diagram_text and not cli_ctx.json_only:
-        _ = output_file.write_text(diagram_text)
-        if not cli_ctx.quiet:
-            output.ctx.console.print(f"Diagram saved to {output_file}")
-    elif output_file:
-        _write_output_file(output_file, callers)
-
-    if cli_ctx.json_only:
-        _emit_json(output, callers)
-    elif diagram_text is not None:
-        if output_file is None:
-            print(diagram_text)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        callers_list = callers.get("callers", [])
-        src = callers.get("source", "unknown")
-        stats: dict[str, Any] = callers.get("stats", {})  # pyright: ignore[reportAssignmentType]
-        count = stats.get("count", len(callers_list))
-        max_depth_value = stats.get("max_depth", 1)
-
-        table = Table(
-            title=f"Callers of '{symbol}' (Source: {src}, Count: {count}, Max depth: {max_depth_value})",
-        )
-        table.add_column("Caller", style="cyan")
-        table.add_column("Location", style="yellow")
-        table.add_column("Depth", style="magenta")
-        table.add_column("Relation", style="green")
-        if show_path:
-            table.add_column("Path", style="white")
-
-        for call in callers_list:
-            loc = call["location"]
-            depth = str(call.get("depth", 1))
-            row = [
-                call["from_symbol"],
-                f"{loc['file']}:{loc['line']}",
-                depth,
-                call.get("relation", "direct"),
-            ]
-            if show_path:
-                row.append(" -> ".join(call.get("path", [])))
-            table.add_row(*row)
-        output.ctx.console.print(table)
-
-
-@app.command("callees")
-def callees_cmd(
-    ctx: typer.Context,
-    symbol: Annotated[str, typer.Argument(help="Symbol to find outgoing calls for")],
-    format: Annotated[
-        str,
-        typer.Option("--format", "-f", help="Output format: table, mermaid, plantuml"),
-    ] = "table",
-    max_depth: Annotated[
-        int,
-        typer.Option("--max-depth", help="Maximum call depth to traverse"),
-    ] = 1,
-    include_external: Annotated[
-        bool,
-        typer.Option("--include-external", help="Include calls outside the workspace"),
-    ] = False,
-    show_path: Annotated[
-        bool,
-        typer.Option("--show-path", help="Show call chain path"),
-    ] = False,
-) -> None:
-    """Find all outgoing calls from a symbol (callees)."""
-    cli_ctx, output, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        callees = get_callees(symbol, max_depth=max_depth, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to find callees",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if not include_external:
-        callees = {
-            **callees,
-            "callees": [c for c in callees.get("callees", []) if not c.get("external")],
-        }
-
-    if (
-        path_filters.get("include")
-        or path_filters.get("exclude")
-        or path_filters.get("git_tracked")
-    ):
-        allowed = _filter_paths(
-            paths=[Path.cwd()],
-            filters=path_filters,
-            allow_notebooks=config.notebook_support,
-            output=output,
-        )
-        allowed_rel = set()
-        for allowed_path in allowed:
-            allowed_rel.add(allowed_path.as_posix())
-            try:
-                allowed_rel.add(allowed_path.relative_to(Path.cwd()).as_posix())
-            except ValueError:
-                continue
-        callees = {
-            **callees,
-            "callees": [
-                c
-                for c in callees.get("callees", [])
-                if c.get("location", {}).get("file") in allowed_rel
-            ],
-        }
-
-    diagram_text = None
-    if format == "mermaid":
-        diagram_text = CallGraphFormatter.to_mermaid(symbol, callees.get("callees", []), "outgoing")
-    elif format == "plantuml":
-        diagram_text = CallGraphFormatter.to_plantuml(
-            symbol, callees.get("callees", []), "outgoing"
-        )
-
-    if output_file and diagram_text and not cli_ctx.json_only:
-        _ = output_file.write_text(diagram_text)
-        if not cli_ctx.quiet:
-            output.ctx.console.print(f"Diagram saved to {output_file}")
-    elif output_file:
-        _write_output_file(output_file, callees)
-
-    if cli_ctx.json_only:
-        _emit_json(output, callees)
-    elif diagram_text is not None:
-        if output_file is None:
-            print(diagram_text)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        callees_list = callees.get("callees", [])
-        src = callees.get("source", "unknown")
-        stats: dict[str, Any] = callees.get("stats", {})  # pyright: ignore[reportAssignmentType]
-        count = stats.get("count", len(callees_list))
-        max_depth_value = stats.get("max_depth", 1)
-
-        table = Table(
-            title=f"Callees of '{symbol}' (Source: {src}, Count: {count}, Max depth: {max_depth_value})",
-        )
-        table.add_column("Callee", style="cyan")
-        table.add_column("Location", style="yellow")
-        table.add_column("Depth", style="magenta")
-        table.add_column("Relation", style="green")
-        if show_path:
-            table.add_column("Path", style="white")
-
-        for call in callees_list:
-            loc = call["location"]
-            depth = str(call.get("depth", 1))
-            row = [
-                call["to_symbol"],
-                f"{loc['file']}:{loc['line']}",
-                depth,
-                call.get("relation", "direct"),
-            ]
-            if show_path:
-                row.append(" -> ".join(call.get("path", [])))
-            table.add_row(*row)
-        output.ctx.console.print(table)
-
-
-@app.command("code-actions")
-def code_actions_cmd(
-    ctx: typer.Context,
-    location: Annotated[
-        str,
-        typer.Argument(..., help="Location in format file:line:col"),
-    ],
-    index: Annotated[
-        int | None,
-        typer.Option("--index", "-i", help="Select a specific action by 1-based index"),
-    ] = None,
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply the selected action"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying selected action"),
-    ] = False,
-    confirm_annotations: Annotated[
-        bool,
-        typer.Option("--confirm-annotations", help="Allow edits that require change annotations"),
-    ] = False,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-    patch_file: Annotated[
-        Path | None,
-        typer.Option("--patch-file", help="Write unified diff output to a file"),
-    ] = None,
-) -> None:
-    """Get available code actions for a location."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        # Parse location (file:line:col)
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-
-        actions = get_code_actions(file_path, line, col, **lsp_config)
-
-        if index is not None:
-            from .core import apply_code_action
-
-            if apply and not yes:
-                if cli_ctx.json_only:
-                    error_handler.handle_general_error(
-                        "Apply requires confirmation",
-                        details={"message": "Use --yes to confirm applying the selected action."},
-                    )
-                confirm = typer.confirm("Apply selected code action?")
-                if not confirm:
-                    output.output_warning("Aborted applying action.")
-                    return
-
-            action_result = apply_code_action(
-                file_path,
-                line,
-                col,
-                index,
-                apply=apply,
-                confirm_annotations=confirm_annotations,
-                **lsp_config,
-            )
-            if patch_file and not apply:
-                patch_text = action_result.get("patch") or ""
-                if patch_text.strip():
-                    patch_file.parent.mkdir(parents=True, exist_ok=True)
-                    _ = patch_file.write_text(patch_text)
-                elif not cli_ctx.quiet and not cli_ctx.json_only:
-                    output.ctx.console.print("[yellow]No patch content to write.[/yellow]")
-            if output_file:
-                _write_output_file(output_file, {"actions": actions, "result": action_result})
-
-            if cli_ctx.json_only:
-                _emit_json(output, {"actions": actions, "result": action_result})
-            elif not cli_ctx.quiet:
-                if action_result.get("previews"):
-                    import difflib
-
-                    previews = action_result.get("previews", [])
-                    for i, preview in enumerate(previews):
-                        if i >= max_previews:
-                            break
-                        if preview.get("needs_confirmation"):
-                            output.ctx.console.print(
-                                "[yellow]Action requires confirmation via change annotations. "
-                                "Use --confirm-annotations to apply.[/yellow]",
-                            )
-                        before = preview.get("before", "").splitlines(keepends=True)
-                        after = preview.get("after", "").splitlines(keepends=True)
-                        path = preview.get("file", "unknown")
-                        diff = difflib.unified_diff(
-                            before,
-                            after,
-                            fromfile=f"{path}:before",
-                            tofile=f"{path}:after",
-                        )
-                        output.ctx.console.print("".join(diff))
-                    if len(previews) > max_previews:
-                        output.ctx.console.print(
-                            f"[yellow]Showing {max_previews} of {len(previews)} previews. Use --json-only for full output.[/yellow]",
-                        )
-                else:
-                    output.ctx.console.print(action_result.get("message", "Operation complete"))
-                if patch_file and not apply and (action_result.get("patch") or "").strip():
-                    output.ctx.console.print(f"[green]Wrote patch file: {patch_file}[/green]")
-                if patch_file and apply:
-                    output.ctx.console.print(
-                        "[yellow]Patch file output is only available for preview mode (no --apply).[/yellow]",
-                    )
-            return
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to get code actions",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, {"actions": actions})
-
-    if cli_ctx.json_only:
-        _emit_json(output, {"actions": actions})
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        table = Table(title=f"Code Actions at {location}")
-        table.add_column("Title", style="cyan")
-        table.add_column("Kind", style="green")
-        table.add_column("Category", style="magenta")
-
-        for action in actions:
-            title = action.get("title", "Unknown")
-            kind = action.get("kind", "Unknown")
-            category = action.get("category", "unknown")
-            table.add_row(title, kind, category)
-
-        output.ctx.console.print(table)
-
-
-@app.command("index-workspace")
-def index_workspace_cmd(
-    ctx: typer.Context,
-    output: Annotated[
-        Path | None,
-        typer.Option("--output", "-o", help="Output file for index"),
-    ] = None,
-    force: Annotated[
-        bool,
-        typer.Option("--force", "-f", help="Force rebuild index"),
-    ] = False,
-    parallel: Annotated[
-        bool,
-        typer.Option("--parallel", "-p", help="Enable parallel indexing for faster processing"),
-    ] = False,
-) -> None:
-    """Generate and optionally save workspace index.
-
-    Parallel indexing uses multiple threads to process files concurrently,
-    significantly reducing indexing time for large workspaces.
-    """
-    cli_ctx, output_mgr, error_handler, config, lsp_config, path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        # Pass force and parallel flags to core -> indexer
-        from .core import index_workspace
-
-        if not cli_ctx.quiet and not cli_ctx.json_only:
-            from rich.progress import Progress
-
-            with Progress(console=output_mgr.ctx.console) as progress:
-                index = index_workspace(
-                    Path.cwd(), force=force, progress=progress, parallel=parallel, **lsp_config
-                )
-        else:
-            index = index_workspace(Path.cwd(), force=force, parallel=parallel, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to index workspace",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if (
-        path_filters.get("include")
-        or path_filters.get("exclude")
-        or path_filters.get("git_tracked")
-    ):
-        allowed = _filter_paths(
-            paths=[Path.cwd()],
-            filters=path_filters,
-            allow_notebooks=config.notebook_support,
-            output=output_mgr,
-        )
-        allowed_rel = set()
-        for allowed_path in allowed:
-            allowed_rel.add(allowed_path.as_posix())
-            try:
-                allowed_rel.add(allowed_path.relative_to(Path.cwd()).as_posix())
-            except ValueError:
-                continue
-        index = index.model_copy(
-            update={
-                "symbols": [s for s in index.symbols if s.location.file in allowed_rel],
-                "calls": [c for c in index.calls if c.location.file in allowed_rel],
-                "total_symbols": len([s for s in index.symbols if s.location.file in allowed_rel]),
-            },
-        )
-
-    if output:
-        _ = output.write_text(index.model_dump_json(indent=2))
-        if not cli_ctx.quiet:
-            output_mgr.ctx.console.print(f"Workspace index saved to {output}")
-    elif output_file:
-        _write_output_file(output_file, index.model_dump())
-    elif cli_ctx.json_only:
-        _emit_json(output_mgr, index.model_dump())
-    elif not cli_ctx.quiet:
-        output_mgr.ctx.console.print(f"Indexed {index.total_symbols} symbols")
-
-
-@app.command("format")
-def format_cmd(
-    ctx: typer.Context,
-    file: Annotated[Path, typer.Argument(..., help="File to format")],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply formatting to file"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying formatting"),
-    ] = False,
-    start_line: Annotated[int | None, typer.Option("--start-line")] = None,
-    start_col: Annotated[int | None, typer.Option("--start-col")] = None,
-    end_line: Annotated[int | None, typer.Option("--end-line")] = None,
-    end_col: Annotated[int | None, typer.Option("--end-col")] = None,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Format a document or a range using Ruff LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying formatting."},
-            )
-        confirm = typer.confirm("Apply formatting?")
-        if not confirm:
-            output.output_warning("Aborted formatting.")
-            return
-
-    try:
-        if all(v is not None for v in (start_line, start_col, end_line, end_col)):
-            result = format_range(
-                file,
-                start_line or 1,
-                start_col or 1,
-                end_line or 1,
-                end_col or 1,
-                apply=apply,
-                **lsp_config,
-            )
-        else:
-            result = format_document(file, apply=apply, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Formatting failed", details={"error": str(exc)})
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-        else:
-            output.ctx.console.print(result.get("message", "Formatting complete."))
-
-
-@app.command("organize-imports")
-def organize_imports_cmd(
-    ctx: typer.Context,
-    file: Annotated[Path, typer.Argument(..., help="File to organize imports for")],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply changes to file"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying changes"),
-    ] = False,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Organize imports via Ruff LSP code actions."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying changes."},
-            )
-        confirm = typer.confirm("Apply organize imports?")
-        if not confirm:
-            output.output_warning("Aborted organize imports.")
-            return
-
-    try:
-        result = organize_imports(file, apply=apply, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Organize imports failed", details={"error": str(exc)})
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-        else:
-            output.ctx.console.print(result.get("message", "Organize imports complete."))
-
-
-@app.command("fix-all")
-def fix_all_cmd(
-    ctx: typer.Context,
-    file: Annotated[Path, typer.Argument(..., help="File to fix")],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply fixes to file"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying fixes"),
-    ] = False,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Apply fix-all actions via Ruff LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying fixes."},
-            )
-        confirm = typer.confirm("Apply fix-all action?")
-        if not confirm:
-            output.output_warning("Aborted fix-all.")
-            return
-
-    try:
-        result = fix_all(file, apply=apply, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Fix-all failed", details={"error": str(exc)})
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-        else:
-            output.ctx.console.print(result.get("message", "Fix-all complete."))
-
-
-@app.command("suggest-imports")
-def suggest_imports_cmd(
-    ctx: typer.Context,
-    location: Annotated[
-        str,
-        typer.Argument(..., help="Location in format file:line:col"),
-    ],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply the first import suggestion"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying the suggestion"),
-    ] = False,
-) -> None:
-    """Get import suggestions for a location (BasedPyright auto-import)."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying the suggestion."},
-            )
-            return
-        confirm = typer.confirm("Apply the first import suggestion?")
-        if not confirm:
-            output.output_warning("Aborted applying import suggestion.")
-            return
-
-    try:
-        # Parse location (file:line:col)
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-
-        result = suggest_imports(file_path, line, col, apply=apply, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Import suggestions failed",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.table import Table
-
-        suggestions = result.get("suggestions", [])
-        if not suggestions:
-            output.ctx.console.print(result.get("message", "No import suggestions available."))
-            return
-
-        # Display suggestions in a table
-        table = Table(title=f"Import Suggestions ({len(suggestions)} found)")
-        table.add_column("#", style="cyan", width=4)
-        table.add_column("Suggestion", style="green")
-        table.add_column("Kind", style="yellow")
-        table.add_column("Preview", style="white")
-
-        for i, suggestion in enumerate(suggestions, 1):
-            preview = suggestion.get("preview", "")
-            # Truncate long previews
-            if len(preview) > 60:
-                preview = preview[:57] + "..."
-            table.add_row(
-                str(i),
-                suggestion.get("title", "Unnamed"),
-                suggestion.get("kind", "unknown"),
-                preview,
-            )
-
-        output.ctx.console.print(table)
-
-        # Show apply message
-        if result.get("applied"):
-            output.ctx.console.print(
-                f"[green]Applied: {result.get('applied_suggestion', 'Import suggestion')}[/green]"
-            )
-            if result.get("backup_dir"):
-                output.ctx.console.print(f"Backup: {result['backup_dir']}")
-        elif not apply:
-            output.ctx.console.print(result.get("message", "Use --apply to add the import."))
-
-
-@app.command("ignore-comment")
-def ignore_comment_cmd(
-    ctx: typer.Context,
-    location: Annotated[
-        str,
-        typer.Argument(..., help="Location in format file:line:col"),
-    ],
-    error_code: Annotated[
-        str | None,
-        typer.Option(
-            "--error-code",
-            "-e",
-            help="Specific error code to ignore (e.g., 'reportOptionalMemberAccess')",
-        ),
-    ] = None,
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply the type ignore comment"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying the comment"),
-    ] = False,
-    confirm_annotations: Annotated[
-        bool,
-        typer.Option("--confirm-annotations", help="Allow edits that require change annotations"),
-    ] = False,
-) -> None:
-    """Add a '# type: ignore' comment to suppress a diagnostic (BasedPyright)."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying the ignore comment."},
-            )
-            return
-        confirm = typer.confirm(f"Add type ignore comment to {location}?")
-        if not confirm:
-            output.output_warning("Aborted adding ignore comment.")
-            return
-
-    try:
-        # Parse location (file:line:col)
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-
-        result = add_type_ignore_comment(
-            file_path,
-            line,
-            col,
-            error_code=error_code,
-            apply=apply,
-            confirm_annotations=confirm_annotations,
-            **lsp_config,
-        )
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Failed to add type ignore comment",
-            details={"error": str(exc)},
-        )
-        return  # Exit early on error
-
-    if output_file:
-        _write_output_file(output_file, result)
-
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        from rich.syntax import Syntax
-
-        # Show error if no ignore actions available
-        if not result.get("applied") and result.get("actions_available", 0) == 0:
-            output.ctx.console.print(
-                f"[yellow]{result.get('message', 'No ignore actions available')}[/yellow]"
-            )
-            if "hint" in result:
-                output.ctx.console.print(f"[dim]Hint: {result['hint']}[/dim]")
-            return
-
-        # Show preview if available
-        previews = result.get("previews", [])
-        if previews and not apply:
-            for preview in previews:
-                output.ctx.console.print(f"\n[bold]File:[/bold] {preview['file']}")
-                output.ctx.console.print(f"[bold]Action:[/bold] {preview.get('title', 'Unnamed')}")
-
-                # Show unified diff if available
-                patch = result.get("patch")
-                if patch:
-                    output.ctx.console.print("\n[bold]Diff:[/bold]")
-                    syntax = Syntax(patch, "diff", theme="monokai", line_numbers=False)
-                    output.ctx.console.print(syntax)
-
-                # Show before/after preview
-                before = preview.get("before", "")
-                after = preview.get("after", "")
-                if before and after:
-                    lines_before = before.splitlines()
-                    lines_after = after.splitlines()
-                    for _i, (before_line, after_line) in enumerate(
-                        zip(lines_before, lines_after, strict=False)
-                    ):
-                        if before_line != after_line:
-                            output.ctx.console.print(f"[red]- {before_line}[/red]")
-                            output.ctx.console.print(f"[green]+ {after_line}[/green]")
-                            break  # Only show the first changed line for brevity
-
-            output.ctx.console.print(
-                f"\n[cyan]{result.get('message', 'Use --apply to add the ignore comment.')}[/cyan]"
-            )
-            return
-
-        # Show success message
-        if result.get("applied"):
-            output.ctx.console.print("[green]Added type ignore comment[/green]")
-            if result.get("action_title"):
-                output.ctx.console.print(f"[dim]Action: {result['action_title']}[/dim]")
-            if result.get("backup_dir"):
-                output.ctx.console.print(f"Backup: {result['backup_dir']}")
-        else:
-            output.ctx.console.print(result.get("message", "Failed to add ignore comment."))
-
-
-@app.command("hover")
-def hover_cmd(
-    ctx: typer.Context,
-    location: Annotated[str, typer.Argument(..., help="Location in format file:line:col")],
-) -> None:
-    """Get hover information from BasedPyright LSP.
-
-    Supports:
-    - Symbol documentation (functions, classes, variables)
-    - Operator hover (shows dunder method like __add__, __mul__, etc.)
-
-    Example for operators:
-        vds-lsp hover " myfile.py:10:8"  # Hover on the + operator
-    """
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    try:
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-        result = hover(Path(file_path), line, col, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Hover failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        # Enhanced display for operator hovers
-        if result.get("is_operator"):
-            from rich.markdown import Markdown
-            from rich.panel import Panel
-
-            operator_info = result.get("operator_info", {})
-            hover_result = result.get("result", {})
-
-            # Display operator info panel
-            if operator_info:
-                output.ctx.console.print(
-                    Panel(
-                        Markdown(operator_info.get("description", "Operator hover")),
-                        title="[bold cyan]Operator Information[/bold cyan]",
-                        border_style="cyan",
-                    )
-                )
-
-            # Display the actual hover result
-            contents = hover_result.get("contents") if hover_result else None
-            if contents:
-                if isinstance(contents, str):
-                    output.ctx.console.print(
-                        Panel(
-                            Markdown(contents),
-                            title="Hover Result",
-                            border_style="green",
-                        )
-                    )
-                elif isinstance(contents, list):
-                    for item in contents:
-                        if isinstance(item, str):
-                            output.ctx.console.print(
-                                Panel(
-                                    Markdown(item),
-                                    title="Hover Result",
-                                    border_style="green",
-                                )
-                            )
-                        elif isinstance(item, dict):
-                            value = item.get("value", "")
-                            if value:
-                                output.ctx.console.print(
-                                    Panel(
-                                        Markdown(value),
-                                        title="Hover Result",
-                                        border_style="green",
-                                    )
-                                )
-        else:
-            output.ctx.console.print(result.get("message", "OK"))
-
-
-@app.command("completion")
-def completion_cmd(
-    ctx: typer.Context,
-    location: Annotated[str, typer.Argument(..., help="Location in format file:line:col")],
-) -> None:
-    """Get completion items from BasedPyright LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    try:
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-        result = completion(Path(file_path), line, col, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Completion failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "OK"))
-
-
-@app.command("rename")
-def rename_cmd(
-    ctx: typer.Context,
-    location: Annotated[str, typer.Argument(..., help="Location in format file:line:col")],
-    new_name: Annotated[str, typer.Argument(..., help="New symbol name")],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply rename edits"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying rename"),
-    ] = False,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Rename a symbol via BasedPyright LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying rename."},
-            )
-        confirm = typer.confirm("Apply rename?")
-        if not confirm:
-            output.output_warning("Aborted rename.")
-            return
-    try:
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-        result = rename_symbol(Path(file_path), line, col, new_name, apply=apply, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Rename failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-        else:
-            output.ctx.console.print(result.get("message", "Rename complete."))
-
-
-@app.command("signature-help")
-def signature_help_cmd(
-    ctx: typer.Context,
-    location: Annotated[str, typer.Argument(..., help="Location in format file:line:col")],
-) -> None:
-    """Get signature help from BasedPyright LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    try:
-        parts = location.split(":")
-        if len(parts) < 3:
-            raise ValueError("Location must be in format file:line:col")
-        file_path, line, col = parts[0], int(parts[1]), int(parts[2])
-        result = signature_help(Path(file_path), line, col, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Signature help failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "OK"))
-
-
-@app.command("inlay-hints")
-def inlay_hints_cmd(
-    ctx: typer.Context,
-    file: Annotated[Path, typer.Argument(..., help="File to request inlay hints for")],
-    inlay_return_types: Annotated[
-        bool,
-        typer.Option("--inlay-return-types", help="Enable function return type hints"),
-    ] = True,
-    inlay_variable_types: Annotated[
-        bool,
-        typer.Option("--inlay-variable-types", help="Enable variable type hints"),
-    ] = True,
-    inlay_function_parameters: Annotated[
-        bool,
-        typer.Option("--inlay-function-parameters", help="Enable function parameter name hints"),
-    ] = True,
-    inlay_generic_types: Annotated[
-        bool,
-        typer.Option("--inlay-generic-types", help="Enable generic type hints"),
-    ] = True,
-    inlay_parameter_names_matching: Annotated[
-        bool,
-        typer.Option(
-            "--inlay-parameter-names-matching", help="Enable hints when param name matches arg name"
-        ),
-    ] = False,
-) -> None:
-    """Get inlay hints from BasedPyright LSP with granular configuration.
-
-    Examples:
-        vds-lsp inlay-hints file.py                           # Use defaults (all enabled except matching)
-        vds-lsp inlay-hints file.py --inlay-return-types     # Only return types
-        vds-lsp inlay-hints file.py --no-inlay-variable-types # All except variable types
-        vds-lsp inlay-hints file.py --inlay-return-types --inlay-function-parameters  # Specific hints
-    """
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    try:
-        result = inlay_hints(
-            file,
-            inlay_return_types=inlay_return_types,
-            inlay_variable_types=inlay_variable_types,
-            inlay_function_parameters=inlay_function_parameters,
-            inlay_generic_types=inlay_generic_types,
-            inlay_parameter_names_matching=inlay_parameter_names_matching,
-            **lsp_config,
-        )
-    except Exception as exc:
-        error_handler.handle_general_error("Inlay hints failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "OK"))
-
-
-@app.command("semantic-tokens")
-def semantic_tokens_cmd(
-    ctx: typer.Context,
-    file: Annotated[Path, typer.Argument(..., help="File to request semantic tokens for")],
-) -> None:
-    """Get semantic tokens from BasedPyright LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    # Parse file:line:col format - strip :line:col suffix if present
-    file_str = str(file)
-    if ":" in file_str and not file_str.startswith(("http://", "https://", "file://")):
-        # Split on : and take first part as file path
-        file_path = Path(file_str.split(":")[0])
-    else:
-        file_path = file
-
-    try:
-        result = semantic_tokens(file_path, **lsp_config)
-    except Exception as exc:
-        error_handler.handle_general_error("Semantic tokens failed", details={"error": str(exc)})
-        return  # Exit early on error
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("message", "OK"))
-
-
-@app.command("health")
-def health_cmd(ctx: typer.Context) -> None:
-    """Report LSP server health status."""
-    cli_ctx, output, error_handler, config, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    try:
-        result = lsp_health(**lsp_config)
-
-        # Add WSL2 status to health check
-        from .utils import is_wsl2, is_wsl_path
-
-        wsl_detected = is_wsl2()
-        workspace_path = Path.cwd()
-        wsl_workspace = is_wsl_path(workspace_path) if wsl_detected else False
-
-        result["wsl2"] = {
-            "detected": wsl_detected,
-            "windows_filesystem": wsl_workspace,
-            "optimization_enabled": config.wsl_optimize if config else False,
-        }
-
-        # Add detected type checker to health check
-        from .models.project_detector import ProjectDetector
-
-        detector = ProjectDetector(workspace_path)
-        tools = detector.detect_all()
-        result["type_checker"] = {
-            "detected": tools.type_checker,
-            "configured": config.type_checker if config else "auto",
-        }
-
-        # Log WSL2 status for user awareness
-        if wsl_detected and wsl_workspace and not cli_ctx.quiet:
-            output.ctx.console.print(
-                "[yellow]WSL2 with Windows filesystem detected (/mnt/c/). "
-                "Performance may be slower than native filesystem.[/yellow]"
-            )
-            if config and config.wsl_optimize:
-                output.ctx.console.print("[green]WSL2 optimization enabled[/green]")
-
-    except Exception as exc:
-        error_handler.handle_general_error("Health check failed", details={"error": str(exc)})
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print(result.get("status", {}))
-
-
-@app.command("batch-format")
-def batch_format_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path],
-        typer.Argument(..., help="Paths to format (files or directories)"),
-    ],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply formatting to files"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying formatting"),
-    ] = False,
-    atomic: Annotated[
-        bool,
-        typer.Option(
-            "--atomic/--no-atomic", help="Backup all files and rollback on error (default: True)"
-        ),
-    ] = True,
-    include: Annotated[
-        list[str] | None,
-        typer.Option("--include", help="Only include paths matching this pattern"),
-    ] = None,
-    exclude: Annotated[
-        list[str] | None,
-        typer.Option("--exclude", help="Exclude paths matching this pattern"),
-    ] = None,
-    git_tracked: Annotated[
-        bool,
-        typer.Option("--git-tracked", "-g", help="Only process git-tracked files"),
-    ] = False,
-    parallel: Annotated[
-        bool,
-        typer.Option("--parallel/--no-parallel", help="Process files in parallel (default: True)"),
-    ] = True,
-    jobs: Annotated[
-        int | None,
-        typer.Option("--jobs", "-j", help="Number of parallel jobs (default: auto-detect)"),
-    ] = None,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Format multiple Python files using Ruff LSP."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying formatting."},
-            )
-        confirm = typer.confirm("Apply formatting to all files?")
-        if not confirm:
-            output.output_warning("Aborted batch formatting.")
-            return
-
-    result: dict[str, Any] = {}
-    try:
-        # Convert include/exclude strings to Path objects
-        include_paths = [Path(p) for p in include] if include else None
-        exclude_paths = [Path(p) for p in exclude] if exclude else None
-
-        if not cli_ctx.quiet and not cli_ctx.json_only:
-            from rich.progress import Progress
-
-            with Progress(console=output.ctx.console) as progress:
-                result = batch_format(
-                    paths,
-                    apply=apply,
-                    atomic=atomic,
-                    include_paths=include_paths,
-                    exclude_paths=exclude_paths,
-                    git_tracked_only=git_tracked,
-                    parallel=parallel,
-                    jobs=jobs,
-                    progress=progress,
-                    **lsp_config,
-                )
-        else:
-            result = batch_format(
-                paths,
-                apply=apply,
-                atomic=atomic,
-                include_paths=include_paths,
-                exclude_paths=exclude_paths,
-                git_tracked_only=git_tracked,
-                parallel=parallel,
-                jobs=jobs,
-                **lsp_config,
-            )
-    except Exception as exc:
-        error_handler.handle_general_error("Batch formatting failed", details={"error": str(exc)})
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-            if len(result.get("previews", [])) > max_previews:
-                output.ctx.console.print(
-                    f"[yellow]Showing {max_previews} of {len(result.get('previews', []))} previews. Use --json-only for full output.[/yellow]",
-                )
-        # Show summary
-        from rich.panel import Panel
-        from rich.table import Table
-
-        summary_table = Table(title="Batch Format Summary")
-        summary_table.add_column("Metric", style="cyan")
-        summary_table.add_column("Value", style="green")
-        summary_table.add_row("Processed", str(result.get("processed", 0)))
-        summary_table.add_row("Modified", str(result.get("modified", 0)))
-        summary_table.add_row("Errors", str(result.get("errors", 0)))
-        if result.get("backup_dir"):
-            summary_table.add_row("Backup", result.get("backup_dir", ""))
-        output.ctx.console.print(Panel(summary_table))
-        if result.get("error_details"):
-            output.ctx.console.print("[yellow]Errors:[/yellow]")
-            for error in result.get("error_details", []):
-                output.ctx.console.print(f"  [red]{error.get('file')}:[/red] {error.get('error')}")
-
-
-@app.command("batch-organize-imports")
-def batch_organize_imports_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path],
-        typer.Argument(..., help="Paths to process (files or directories)"),
-    ],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply changes to files"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying changes"),
-    ] = False,
-    atomic: Annotated[
-        bool,
-        typer.Option(
-            "--atomic/--no-atomic", help="Backup all files and rollback on error (default: True)"
-        ),
-    ] = True,
-    include: Annotated[
-        list[str] | None,
-        typer.Option("--include", help="Only include paths matching this pattern"),
-    ] = None,
-    exclude: Annotated[
-        list[str] | None,
-        typer.Option("--exclude", help="Exclude paths matching this pattern"),
-    ] = None,
-    git_tracked: Annotated[
-        bool,
-        typer.Option("--git-tracked", "-g", help="Only process git-tracked files"),
-    ] = False,
-    parallel: Annotated[
-        bool,
-        typer.Option("--parallel/--no-parallel", help="Process files in parallel (default: True)"),
-    ] = True,
-    jobs: Annotated[
-        int | None,
-        typer.Option("--jobs", "-j", help="Number of parallel jobs (default: auto-detect)"),
-    ] = None,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Organize imports across multiple Python files."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying changes."},
-            )
-        confirm = typer.confirm("Apply import organization to all files?")
-        if not confirm:
-            output.output_warning("Aborted batch import organization.")
-            return
-
-    result: dict[str, Any] = {}
-    try:
-        include_paths = [Path(p) for p in include] if include else None
-        exclude_paths = [Path(p) for p in exclude] if exclude else None
-
-        if not cli_ctx.quiet and not cli_ctx.json_only:
-            from rich.progress import Progress
-
-            with Progress(console=output.ctx.console) as progress:
-                result = batch_organize_imports(
-                    paths,
-                    apply=apply,
-                    atomic=atomic,
-                    include_paths=include_paths,
-                    exclude_paths=exclude_paths,
-                    git_tracked_only=git_tracked,
-                    parallel=parallel,
-                    jobs=jobs,
-                    progress=progress,
-                    **lsp_config,
-                )
-        else:
-            result = batch_organize_imports(
-                paths,
-                apply=apply,
-                atomic=atomic,
-                include_paths=include_paths,
-                exclude_paths=exclude_paths,
-                git_tracked_only=git_tracked,
-                parallel=parallel,
-                jobs=jobs,
-                **lsp_config,
-            )
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Batch import organization failed", details={"error": str(exc)}
-        )
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-            if len(result.get("previews", [])) > max_previews:
-                output.ctx.console.print(
-                    f"[yellow]Showing {max_previews} of {len(result.get('previews', []))} previews. Use --json-only for full output.[/yellow]",
-                )
-        # Show summary
-        from rich.panel import Panel
-        from rich.table import Table
-
-        summary_table = Table(title="Batch Organize Imports Summary")
-        summary_table.add_column("Metric", style="cyan")
-        summary_table.add_column("Value", style="green")
-        summary_table.add_row("Processed", str(result.get("processed", 0)))
-        summary_table.add_row("Modified", str(result.get("modified", 0)))
-        summary_table.add_row("Errors", str(result.get("errors", 0)))
-        if result.get("backup_dir"):
-            summary_table.add_row("Backup", result.get("backup_dir", ""))
-        output.ctx.console.print(Panel(summary_table))
-        if result.get("error_details"):
-            output.ctx.console.print("[yellow]Errors:[/yellow]")
-            for error in result.get("error_details", []):
-                output.ctx.console.print(f"  [red]{error.get('file')}:[/red] {error.get('error')}")
-
-
-@app.command("batch-fix-all")
-def batch_fix_all_cmd(
-    ctx: typer.Context,
-    paths: Annotated[
-        list[Path],
-        typer.Argument(..., help="Paths to fix (files or directories)"),
-    ],
-    apply: Annotated[
-        bool,
-        typer.Option("--apply", "-a", help="Apply fixes to files"),
-    ] = False,
-    yes: Annotated[
-        bool,
-        typer.Option("--yes", "-y", help="Confirm applying fixes"),
-    ] = False,
-    atomic: Annotated[
-        bool,
-        typer.Option(
-            "--atomic/--no-atomic", help="Backup all files and rollback on error (default: True)"
-        ),
-    ] = True,
-    include: Annotated[
-        list[str] | None,
-        typer.Option("--include", help="Only include paths matching this pattern"),
-    ] = None,
-    exclude: Annotated[
-        list[str] | None,
-        typer.Option("--exclude", help="Exclude paths matching this pattern"),
-    ] = None,
-    git_tracked: Annotated[
-        bool,
-        typer.Option("--git-tracked", "-g", help="Only process git-tracked files"),
-    ] = False,
-    parallel: Annotated[
-        bool,
-        typer.Option("--parallel/--no-parallel", help="Process files in parallel (default: True)"),
-    ] = True,
-    jobs: Annotated[
-        int | None,
-        typer.Option("--jobs", "-j", help="Number of parallel jobs (default: auto-detect)"),
-    ] = None,
-    max_previews: Annotated[
-        int,
-        typer.Option("--max-previews", help="Limit number of preview diffs"),
-    ] = 5,
-) -> None:
-    """Apply fix-all code actions across multiple Python files."""
-    cli_ctx, output, error_handler, _, lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-    if apply and not yes:
-        if cli_ctx.json_only:
-            error_handler.handle_general_error(
-                "Apply requires confirmation",
-                details={"message": "Use --yes to confirm applying fixes."},
-            )
-        confirm = typer.confirm("Apply fix-all actions to all files?")
-        if not confirm:
-            output.output_warning("Aborted batch fix-all.")
-            return
-
-    result: dict[str, Any] = {}
-    try:
-        include_paths = [Path(p) for p in include] if include else None
-        exclude_paths = [Path(p) for p in exclude] if exclude else None
-
-        if not cli_ctx.quiet and not cli_ctx.json_only:
-            from rich.progress import Progress
-
-            with Progress(console=output.ctx.console) as progress:
-                result = batch_fix_all(
-                    paths,
-                    apply=apply,
-                    atomic=atomic,
-                    include_paths=include_paths,
-                    exclude_paths=exclude_paths,
-                    git_tracked_only=git_tracked,
-                    parallel=parallel,
-                    jobs=jobs,
-                    progress=progress,
-                    **lsp_config,
-                )
-        else:
-            result = batch_fix_all(
-                paths,
-                apply=apply,
-                atomic=atomic,
-                include_paths=include_paths,
-                exclude_paths=exclude_paths,
-                git_tracked_only=git_tracked,
-                parallel=parallel,
-                jobs=jobs,
-                **lsp_config,
-            )
-    except Exception as exc:
-        error_handler.handle_general_error("Batch fix-all failed", details={"error": str(exc)})
-
-    if output_file:
-        _write_output_file(output_file, result)
-    if cli_ctx.json_only:
-        _emit_json(output, result)
-    elif not cli_ctx.quiet:
-        if result.get("previews"):
-            import difflib
-
-            for i, preview in enumerate(result.get("previews", [])):
-                if i >= max_previews:
-                    break
-                before = preview.get("before", "").splitlines(keepends=True)
-                after = preview.get("after", "").splitlines(keepends=True)
-                path = preview.get("file", "unknown")
-                diff = difflib.unified_diff(
-                    before,
-                    after,
-                    fromfile=f"{path}:before",
-                    tofile=f"{path}:after",
-                )
-                output.ctx.console.print("".join(diff))
-            if len(result.get("previews", [])) > max_previews:
-                output.ctx.console.print(
-                    f"[yellow]Showing {max_previews} of {len(result.get('previews', []))} previews. Use --json-only for full output.[/yellow]",
-                )
-        # Show summary
-        from rich.panel import Panel
-        from rich.table import Table
-
-        summary_table = Table(title="Batch Fix-All Summary")
-        summary_table.add_column("Metric", style="cyan")
-        summary_table.add_column("Value", style="green")
-        summary_table.add_row("Processed", str(result.get("processed", 0)))
-        summary_table.add_row("Modified", str(result.get("modified", 0)))
-        summary_table.add_row("Errors", str(result.get("errors", 0)))
-        if result.get("backup_dir"):
-            summary_table.add_row("Backup", result.get("backup_dir", ""))
-        output.ctx.console.print(Panel(summary_table))
-        if result.get("error_details"):
-            output.ctx.console.print("[yellow]Errors:[/yellow]")
-            for error in result.get("error_details", []):
-                output.ctx.console.print(f"  [red]{error.get('file')}:[/red] {error.get('error')}")
-
-
-@app.command("detect-tools")
-def detect_tools_cmd(
-    ctx: typer.Context,
-    path: Annotated[
-        Path,
-        typer.Argument(help="Project path to analyze", exists=True, dir_okay=True),
-    ] = Path.cwd(),
-    format: Annotated[
-        Literal["table", "json"],
-        typer.Option("--format", "-f", help="Output format"),
-    ] = "table",
-) -> None:
-    """Detect and display project tools and configuration.
-
-    This command analyzes a Python project and detects:
-    - Package manager (uv, poetry, pdm, hatch, pipenv, pip)
-    - Type checker (mypy, basedpyright, pyright)
-    - Formatter (ruff, black)
-    - Linter (ruff, pylint, flake8)
-    - Test runner (pytest, unittest)
-    - Coverage tool (coverage)
-
-    Detection priority: lock files > config sections > dependencies > commands
-
-    Examples:
-        vds-lsp detect-tools
-        vds-lsp detect-tools /path/to/project
-        vds-lsp detect-tools --format json
-        vds-lsp detect-tools /path/to/project --format json
-    """
-    cli_ctx, output, error_handler, _config, _lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(ctx)
-    )
-
-    try:
-        from .models.project_detector import ProjectDetector
-
-        detector = ProjectDetector(path)
-        tools = detector.detect_all()
-
-        # Build output payload
-        payload = {
-            "package_manager": tools.package_manager,
-            "type_checker": tools.type_checker,
-            "formatter": tools.formatter,
-            "linter": tools.linter,
-            "test_runner": tools.test_runner,
-            "coverage_tool": tools.coverage_tool,
-            "install_command": tools.get_install_command(),
-            "test_command": tools.get_test_command(),
-            "project_path": str(path),
-        }
-
-        if output_file:
-            _write_output_file(output_file, payload)
-
-        if cli_ctx.json_only or format == "json":
-            _emit_json(output, payload)
-        elif not cli_ctx.quiet:
-            # Table format using Rich
-            from rich.table import Table
-
-            table = Table(title=f"Project Tools Detection - {path.name}")
-            table.add_column("Category", style="cyan")
-            table.add_column("Tool", style="green")
-            table.add_column("Details", style="yellow")
-
-            table.add_row("Package Manager", tools.package_manager, tools.get_install_command())
-            table.add_row("Type Checker", tools.type_checker, "")
-            table.add_row("Formatter", tools.formatter, "")
-            table.add_row("Linter", tools.linter, "")
-            table.add_row("Test Runner", tools.test_runner, tools.get_test_command())
-            table.add_row("Coverage", tools.coverage_tool, "")
-
-            output.ctx.console.print(table)
-
-    except Exception as exc:
-        error_handler.handle_general_error(
-            "Tools detection failed",
-            details={"error": str(exc), "path": str(path)},
-        )
-
-
-@app.command("daemon")
-def daemon_cmd(
-    ctx: typer.Context,
-    action: Annotated[
-        str,
-        typer.Argument(..., help="Action to perform: start, stop, status, restart"),
-    ],
-    timeout: Annotated[
-        int,
-        typer.Option(
-            "--timeout", "-t", help="Timeout for daemon start/restart (seconds)", show_default=False
-        ),
-    ] = 30,
-    idle_timeout: Annotated[
-        int,
-        typer.Option(
-            "--idle-timeout",
-            "-i",
-            help="Daemon idle timeout before auto-shutdown (seconds)",
-            show_default=False,
-        ),
-    ] = 300,
-    max_clients: Annotated[
-        int,
-        typer.Option(
-            "--max-clients",
-            "-m",
-            help="Maximum concurrent clients (default: 10)",
-            show_default=False,
-        ),
-    ] = 10,
-    hot_reload: Annotated[
-        bool,
-        typer.Option("--hot-reload/--no-hot-reload", help="Enable/disable config hot reload"),
-    ] = True,
-    force: Annotated[
-        bool,
-        typer.Option("--force", "-f", help="Force stop (SIGKILL)"),
-    ] = False,
-) -> None:
-    """Manage the LSP daemon process.
-
-    Examples:
-        vds-lsp-orchestrator daemon start
-        vds-lsp-orchestrator daemon status
-        vds-lsp-orchestrator daemon stop --force
-        vds-lsp-orchestrator daemon restart --idle-timeout 600 --max-clients 20
-        vds-lsp-orchestrator daemon start --no-hot-reload
-    """
-    cli_ctx, output, error_handler, _config, _lsp_config, _path_filters, output_file, _verbose = (
-        _get_state(
-            ctx,
-        )
-    )
-    root = Path.cwd()
-
-    try:
-        if action == "start":
-            result = daemon_start(
-                root,
-                timeout=timeout,
-                idle_timeout=idle_timeout,
-                max_clients=max_clients,
-                config_file=_lsp_config.get("config_file"),
-                lsp_server=_lsp_config.get("lsp_server"),
-                hot_reload=hot_reload,
-            )
-        elif action == "stop":
-            result = daemon_stop(
-                root,
-                force=force,
-                config_file=_lsp_config.get("config_file"),
-            )
-        elif action == "status":
-            result = daemon_status(
-                root,
-                config_file=_lsp_config.get("config_file"),
-            )
-        elif action == "restart":
-            result = daemon_restart(
-                root,
-                timeout=timeout,
-                idle_timeout=idle_timeout,
-                max_clients=max_clients,
-                config_file=_lsp_config.get("config_file"),
-                hot_reload=hot_reload,
-            )
-        else:
-            error_handler.handle_general_error(
-                f"Invalid action: {action}",
-                details={"valid_actions": "start, stop, status, restart"},
-            )
-            return
-
-        if output_file:
-            _write_output_file(output_file, result)
-
-        if cli_ctx.json_only:
-            _emit_json(output, result)
-        elif not cli_ctx.quiet:
-            # Format status output nicely
-            if action == "status":
-                from rich.table import Table
-
-                status_table = Table(title="LSP Daemon Status")
-                status_table.add_column("Property", style="cyan")
-                status_table.add_column("Value", style="green")
-
-                status_table.add_row("Running", "Yes" if result.get("running") else "No")
-                if result.get("pid"):
-                    status_table.add_row("PID", str(result.get("pid")))
-                if result.get("socket_path"):
-                    status_table.add_row("Socket", result.get("socket_path", ""))
-                if result.get("uptime_seconds"):
-                    import datetime
-
-                    uptime = int(result.get("uptime_seconds", 0))
-                    uptime_str = str(datetime.timedelta(seconds=uptime))
-                    status_table.add_row("Uptime", uptime_str)
-                if result.get("client_count") is not None:
-                    client_count = result.get("client_count", 0)
-                    max_clients = result.get("max_clients", 10)
-                    status_table.add_row("Clients", f"{client_count}/{max_clients}")
-                    if result.get("active_clients"):
-                        active_clients = result.get("active_clients", [])
-                        if active_clients:
-                            status_table.add_row(
-                                "Active IDs",
-                                ", ".join(active_clients[:5])
-                                + ("..." if len(active_clients) > 5 else ""),
-                            )
-                if result.get("workspace_root"):
-                    status_table.add_row("Workspace", result.get("workspace_root", ""))
-
-                output.ctx.console.print(status_table)
-            else:
-                # For start/stop/restart actions
-                status = result.get("status", "unknown")
-                message = result.get("message", status)
-                if status in ("started", "stopped", "restarted"):
-                    output.ctx.console.print(f"[green]{message}[/green]")
-                elif status == "already_running":
-                    output.ctx.console.print(f"[yellow]{message}[/yellow]")
-                elif status == "error":
-                    output.ctx.console.print(f"[red]{message}[/red]")
-                else:
-                    output.ctx.console.print(message)
-
-    except Exception as exc:
-        error_handler.handle_general_error(
-            f"Daemon {action} failed",
-            details={"error": str(exc)},
-        )
-
-
-def main() -> None:
-    """Main entry point."""
-    app()
-
-
-if __name__ == "__main__":
-    main()