LSP Extensions

AllProducts @query {
    from product
    where {deleted_at @null}
    select {id, handle, status}
}

use facet::Facet;
use roam::service;

/// Service implemented by LSP extensions.
#[service]
pub trait StyxLspExtension {
    /// Initialize the extension. Called once after spawn.
    async fn initialize(&self, params: InitializeParams) -> InitializeResult;

    /// Provide completion items at a cursor position.
    async fn completions(&self, params: CompletionParams) -> Vec<CompletionItem>;

    /// Provide hover information for a symbol.
    async fn hover(&self, params: HoverParams) -> Option<HoverResult>;

    /// Provide inlay hints for a range.
    async fn inlay_hints(&self, params: InlayHintParams) -> Vec<InlayHint>;

    /// Validate the document and return diagnostics.
    async fn diagnostics(&self, params: DiagnosticParams) -> Vec<Diagnostic>;

    /// Provide code actions for a range.
    async fn code_actions(&self, params: CodeActionParams) -> Vec<CodeAction>;

    /// Shutdown the extension gracefully.
    async fn shutdown(&self);
}

/// Service implemented by the Styx LSP for extension callbacks.
#[service]
pub trait StyxLspHost {
    /// Get a subtree of the document at a path.
    async fn get_subtree(&self, path: Vec<String>) -> Option<Value>;

    /// Get the full document tree.
    async fn get_document(&self) -> Value;

    /// Get the raw source text.
    async fn get_source(&self) -> String;

    /// Get the schema source and URI.
    async fn get_schema(&self) -> SchemaInfo;

    /// Convert byte offset to line/character position.
    async fn offset_to_position(&self, offset: u32) -> Position;

    /// Convert line/character position to byte offset.
    async fn position_to_offset(&self, position: Position) -> u32;
}

#[derive(Facet)]
pub struct InitializeParams {
    pub styx_version: String,
    pub document_uri: String,
    pub schema_id: String,
}

#[derive(Facet)]
pub struct InitializeResult {
    pub name: String,
    pub version: String,
    pub capabilities: Vec<Capability>,
}

#[derive(Facet)]
#[repr(u8)]
pub enum Capability {
    Completions = 0,
    Hover = 1,
    InlayHints = 2,
    Diagnostics = 3,
    CodeActions = 4,
    Definition = 5,
}

#[derive(Facet)]
pub struct Position {
    pub line: u32,
    pub character: u32,
}

#[derive(Facet)]
pub struct Range {
    pub start: Position,
    pub end: Position,
}

#[derive(Facet)]
pub struct Cursor {
    pub line: u32,
    pub character: u32,
    pub offset: u32,
}

#[derive(Facet)]
pub struct CompletionParams {
    pub document_uri: String,
    pub cursor: Cursor,
    /// Path to the current location in the document tree.
    /// e.g., ["AllProducts", "@query", "select"]
    pub path: Vec<String>,
    /// Text the user has typed (for filtering).
    pub prefix: String,
    /// The subtree relevant to this completion.
    pub context: Value,
}

#[derive(Facet)]
pub struct CompletionItem {
    /// The text to insert.
    pub label: String,
    /// Short description (e.g., column type).
    pub detail: Option<String>,
    /// Longer description.
    pub documentation: Option<String>,
    /// Item kind for icon selection.
    pub kind: Option<CompletionKind>,
    /// Override sort order.
    pub sort_text: Option<String>,
    /// Text to insert if different from label.
    pub insert_text: Option<String>,
}

#[derive(Facet)]
#[repr(u8)]
pub enum CompletionKind {
    Field = 0,
    Value = 1,
    Keyword = 2,
    Type = 3,
}

#[derive(Facet)]
pub struct HoverParams {
    pub document_uri: String,
    pub cursor: Cursor,
    pub path: Vec<String>,
    pub context: Value,
}

#[derive(Facet)]
pub struct HoverResult {
    /// Markdown content to display.
    pub contents: String,
    /// Range to highlight (optional).
    pub range: Option<Range>,
}

#[derive(Facet)]
pub struct InlayHintParams {
    pub document_uri: String,
    pub range: Range,
    pub context: Value,
}

#[derive(Facet)]
pub struct InlayHint {
    pub position: Position,
    pub label: String,
    pub kind: Option<InlayHintKind>,
    pub padding_left: bool,
    pub padding_right: bool,
}

#[derive(Facet)]
#[repr(u8)]
pub enum InlayHintKind {
    Type = 0,
    Parameter = 1,
}

#[derive(Facet)]
pub struct DiagnosticParams {
    pub document_uri: String,
    /// The full document tree.
    pub tree: Value,
}

#[derive(Facet)]
pub struct Diagnostic {
    pub range: Range,
    pub severity: DiagnosticSeverity,
    pub message: String,
    pub source: Option<String>,
    pub code: Option<String>,
    /// Arbitrary data for code actions.
    pub data: Option<Value>,
}

#[derive(Facet)]
#[repr(u8)]
pub enum DiagnosticSeverity {
    Error = 0,
    Warning = 1,
    Info = 2,
    Hint = 3,
}

#[derive(Facet)]
pub struct CodeActionParams {
    pub document_uri: String,
    pub range: Range,
    /// Diagnostics at this range (for context).
    pub diagnostics: Vec<Diagnostic>,
}

#[derive(Facet)]
pub struct CodeAction {
    pub title: String,
    pub kind: Option<CodeActionKind>,
    pub edit: Option<WorkspaceEdit>,
    pub is_preferred: bool,
}

#[derive(Facet)]
#[repr(u8)]
pub enum CodeActionKind {
    QuickFix = 0,
    Refactor = 1,
    Source = 2,
}

#[derive(Facet)]
pub struct WorkspaceEdit {
    pub changes: Vec<DocumentEdit>,
}

#[derive(Facet)]
pub struct DocumentEdit {
    pub uri: String,
    pub edits: Vec<TextEdit>,
}

#[derive(Facet)]
pub struct TextEdit {
    pub range: Range,
    pub new_text: String,
}

#[derive(Facet)]
pub struct SchemaInfo {
    pub source: String,
    pub uri: String,
}

/// Document tree value - opaque to Roam, interpreted by the extension.
/// This is the Styx document parsed into a tree structure.
pub type Value = facet_styx::Value;