rez-lsp-server 0.1.3

A Language Server Protocol implementation for Rez package manager with intelligent code completion, validation, and navigation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

//! Completion handling for the LSP server.

use std::sync::Arc;
use tower_lsp::jsonrpc::Result;
use tower_lsp::lsp_types::*;
use tracing::info;

use crate::core::PackageDiscovery;
use crate::discovery::PackageDiscoveryImpl;

/// Handle completion requests.
pub async fn handle_completion(
    params: &CompletionParams,
    package_discovery: &Arc<tokio::sync::RwLock<Option<PackageDiscoveryImpl>>>,
) -> Result<Option<CompletionResponse>> {
    info!(
        "Completion requested at {:?}",
        params.text_document_position
    );

    let package_discovery_guard = package_discovery.read().await;

    let completions = if let Some(ref discovery) = *package_discovery_guard {
        // Use real package discovery
        match discovery.get_all_package_names().await {
            Ok(package_names) => {
                let mut completions = Vec::new();

                for package_name in package_names {
                    match discovery.get_package_versions(&package_name).await {
                        Ok(versions) => {
                            if let Some(latest_version) = versions.last() {
                                completions.push(CompletionItem {
                                    label: package_name.clone(),
                                    kind: Some(CompletionItemKind::MODULE),
                                    detail: Some(format!(
                                        "Rez package (latest: {})",
                                        latest_version.version
                                    )),
                                    documentation: latest_version
                                        .description
                                        .as_ref()
                                        .map(|desc| Documentation::String(desc.clone())),
                                    insert_text: Some(package_name),
                                    ..Default::default()
                                });
                            }
                        }
                        Err(e) => {
                            tracing::warn!(
                                "Failed to get versions for package {}: {}",
                                package_name,
                                e
                            );
                        }
                    }
                }

                completions
            }
            Err(e) => {
                tracing::warn!("Failed to get package names: {}", e);
                get_fallback_completions()
            }
        }
    } else {
        // Fallback to static completions if package discovery is not available
        get_fallback_completions()
    };

    Ok(Some(CompletionResponse::Array(completions)))
}

/// Get fallback completions when package discovery is not available.
fn get_fallback_completions() -> Vec<CompletionItem> {
    vec![
        CompletionItem {
            label: "python".to_string(),
            kind: Some(CompletionItemKind::MODULE),
            detail: Some("Python interpreter package".to_string()),
            documentation: Some(Documentation::String(
                "Python programming language interpreter".to_string(),
            )),
            insert_text: Some("python".to_string()),
            ..Default::default()
        },
        CompletionItem {
            label: "maya".to_string(),
            kind: Some(CompletionItemKind::MODULE),
            detail: Some("Autodesk Maya package".to_string()),
            documentation: Some(Documentation::String(
                "Autodesk Maya 3D animation and modeling software".to_string(),
            )),
            insert_text: Some("maya".to_string()),
            ..Default::default()
        },
        CompletionItem {
            label: "houdini".to_string(),
            kind: Some(CompletionItemKind::MODULE),
            detail: Some("SideFX Houdini package".to_string()),
            documentation: Some(Documentation::String(
                "SideFX Houdini 3D animation and VFX software".to_string(),
            )),
            insert_text: Some("houdini".to_string()),
            ..Default::default()
        },
    ]
}