feat: refactor LSP to modular architecture with full feature parity

Major refactoring to bring anvomidav LSP to same level as betlang/wokelang:

LSP Server Changes:
- Refactored 512-line monolithic main.rs into modular architecture
- Created separate handler modules (completion, hover, definition, diagnostics, formatting)
- Added go-to-definition handler (was missing)
- Added formatting handler with indentation support (was missing)
- Migrated to backend.rs + handlers/ structure
- Preserved Rope-based document model and real parser integration
- All 8 integration tests passing

VSCode Extension Enhancements:
- Added 2 new commands (validateProgram, formatDocument)
- Added 4 config toggles (enableDiagnostics, enableCompletion, enableHover, enableFormatting)
- Added context menu integration for validation
- Added keybinding (Ctrl+Shift+F for formatting)
- Maintained ReScript implementation (no TypeScript)

Files Created:
- src/backend.rs - LanguageServer trait implementation
- src/document.rs - Rope-based document state
- src/lib.rs - Module exports
- src/handlers/mod.rs - Handler exports
- src/handlers/completion.rs - Jump/spin type completion
- src/handlers/hover.rs - Figure skating terminology docs
- src/handlers/definition.rs - Go-to-definition for segments/sequences
- src/handlers/diagnostics.rs - ISU rule validation
- src/handlers/formatting.rs - Indentation-based formatting

Files Modified:
- src/main.rs - Reduced from 512 to 23 lines (old version backed up as main.rs.old)
- editors/vscode/package.json - Added commands, config, menus, keybindings
- editors/vscode/src/Extension.res - Added validateProgram and formatDocument commands

Feature Parity Achieved:
✅ Modular LSP architecture (matches betlang/wokelang)
✅ Completion, hover, definition, diagnostics, formatting
✅ Enhanced VSCode extension with extra commands
✅ ReScript-based extension (no TypeScript)
✅ Comprehensive testing (8 integration tests passing)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: Jonathan D.A. Jewell

crates/anv-lsp/src/backend.rs

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: MIT
+// Backend implementation for Anvomidav LSP
+
+use dashmap::DashMap;
+use ropey::Rope;
+use std::sync::Arc;
+use tower_lsp::lsp_types::*;
+use tower_lsp::{Client, LanguageServer};
+
+use crate::document::DocumentState;
+use crate::handlers;
+
+pub struct Backend {
+    pub client: Client,
+    pub document_map: Arc<DashMap<Url, DocumentState>>,
+}
+
+impl Backend {
+    pub fn new(client: Client) -> Self {
+        Self {
+            client,
+            document_map: Arc::new(DashMap::new()),
+        }
+    }
+
+    async fn publish_diagnostics(&self, uri: &Url) {
+        if let Some(doc) = self.document_map.get(uri) {
+            let source = doc.source();
+            let diagnostics = handlers::diagnostics::generate_diagnostics(&source).await;
+            self.client.publish_diagnostics(uri.clone(), diagnostics, None).await;
+        }
+    }
+}
+
+#[tower_lsp::async_trait]
+impl LanguageServer for Backend {
+    async fn initialize(&self, _: InitializeParams) -> tower_lsp::jsonrpc::Result<InitializeResult> {
+        Ok(InitializeResult {
+            capabilities: ServerCapabilities {
+                text_document_sync: Some(TextDocumentSyncCapability::Kind(
+                    TextDocumentSyncKind::FULL,
+                )),
+                completion_provider: Some(CompletionOptions {
+                    trigger_characters: Some(vec![" ".to_string(), "{".to_string()]),
+                    ..Default::default()
+                }),
+                hover_provider: Some(HoverProviderCapability::Simple(true)),
+                definition_provider: Some(OneOf::Left(true)),
+                document_formatting_provider: Some(OneOf::Left(true)),
+                document_symbol_provider: Some(OneOf::Left(true)),
+                ..Default::default()
+            },
+            server_info: Some(ServerInfo {
+                name: "anvomidav-lsp".to_string(),
+                version: Some("0.1.0".to_string()),
+            }),
+            ..Default::default()
+        })
+    }
+
+    async fn initialized(&self, _: InitializedParams) {
+        self.client
+            .log_message(MessageType::INFO, "Anvomidav LSP server initialized")
+            .await;
+    }
+
+    async fn shutdown(&self) -> tower_lsp::jsonrpc::Result<()> {
+        Ok(())
+    }
+
+    async fn did_open(&self, params: DidOpenTextDocumentParams) {
+        let uri = params.text_document.uri;
+        let content = Rope::from_str(&params.text_document.text);
+        let version = params.text_document.version;
+
+        self.document_map.insert(uri.clone(), DocumentState::new(content, version));
+        self.publish_diagnostics(&uri).await;
+    }
+
+    async fn did_change(&self, params: DidChangeTextDocumentParams) {
+        let uri = params.text_document.uri;
+
+        if let Some(mut doc) = self.document_map.get_mut(&uri) {
+            // Full sync - replace entire content
+            if let Some(change) = params.content_changes.into_iter().next() {
+                doc.content = Rope::from_str(&change.text);
+                doc.version = params.text_document.version;
+            }
+        }
+
+        self.publish_diagnostics(&uri).await;
+    }
+
+    async fn did_save(&self, params: DidSaveTextDocumentParams) {
+        self.publish_diagnostics(&params.text_document.uri).await;
+    }
+
+    async fn did_close(&self, params: DidCloseTextDocumentParams) {
+        self.document_map.remove(&params.text_document.uri);
+    }
+
+    async fn hover(&self, params: HoverParams) -> tower_lsp::jsonrpc::Result<Option<Hover>> {
+        let uri = &params.text_document_position_params.text_document.uri;
+
+        if let Some(doc) = self.document_map.get(uri) {
+            let source = doc.source();
+            Ok(handlers::hover::handle_hover(uri, &source, &params).await)
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn completion(
+        &self,
+        params: CompletionParams,
+    ) -> tower_lsp::jsonrpc::Result<Option<CompletionResponse>> {
+        let uri = &params.text_document_position.text_document.uri;
+
+        if let Some(doc) = self.document_map.get(uri) {
+            let source = doc.source();
+            Ok(handlers::completion::handle_completion(uri, &source, &params).await)
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn goto_definition(
+        &self,
+        params: GotoDefinitionParams,
+    ) -> tower_lsp::jsonrpc::Result<Option<GotoDefinitionResponse>> {
+        let uri = &params.text_document_position_params.text_document.uri;
+
+        if let Some(doc) = self.document_map.get(uri) {
+            let source = doc.source();
+            Ok(handlers::definition::handle_definition(uri, &source, &params).await)
+        } else {
+            Ok(None)
+        }
+    }
+
+    async fn formatting(
+        &self,
+        params: DocumentFormattingParams,
+    ) -> tower_lsp::jsonrpc::Result<Option<Vec<TextEdit>>> {
+        let uri = &params.text_document.uri;
+
+        if let Some(doc) = self.document_map.get(uri) {
+            let source = doc.source();
+            Ok(Some(handlers::formatting::format_document(&source).await))
+        } else {
+            Ok(None)
+        }
+    }
+}

crates/anv-lsp/src/document.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+// Document state management for Anvomidav LSP
+
+use ropey::Rope;
+
+pub struct DocumentState {
+    pub content: Rope,
+    pub version: i32,
+}
+
+impl DocumentState {
+    pub fn new(content: Rope, version: i32) -> Self {
+        Self { content, version }
+    }
+
+    pub fn source(&self) -> String {
+        self.content.to_string()
+    }
+}

crates/anv-lsp/src/handlers/completion.rs

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: MIT
+// Completion handler for Anvomidav LSP
+
+use tower_lsp::lsp_types::{CompletionItem, CompletionItemKind, CompletionParams, CompletionResponse, Position, Url};
+
+/// Keywords for Anvomidav choreography DSL
+const KEYWORDS: &[(&str, &str)] = &[
+    ("program", "Define a choreography program"),
+    ("segment", "Define a program segment"),
+    ("sequence", "Define a sequence of elements"),
+    ("transition", "Define a transition between elements"),
+    ("choreography", "Define choreography structure"),
+    ("spiral", "Define a spiral sequence"),
+    ("step", "Define a step sequence"),
+    ("turn", "Define a turn sequence"),
+    ("jump", "Define a jump element"),
+    ("spin", "Define a spin element"),
+    ("lift", "Define a lift element (pairs)"),
+    ("throw", "Define a throw element (pairs)"),
+    ("twist", "Define a twist element (pairs)"),
+    ("death_spiral", "Define a death spiral (pairs)"),
+    ("pattern", "Define an ice dance pattern"),
+    ("timing", "Specify element timing"),
+    ("music", "Music reference"),
+    ("tempo", "Tempo specification"),
+    ("short", "Short program segment"),
+    ("free", "Free program segment"),
+    ("rhythm", "Rhythm dance segment"),
+];
+
+/// Jump types
+const JUMPS: &[(&str, &str)] = &[
+    ("axel", "Axel jump (1.5 rotations forward takeoff)"),
+    ("lutz", "Lutz jump (toe-assisted, outside edge)"),
+    ("flip", "Flip jump (toe-assisted, inside edge)"),
+    ("loop", "Loop jump (edge jump)"),
+    ("salchow", "Salchow jump (edge jump, inside edge)"),
+    ("toe_loop", "Toe loop jump (toe-assisted)"),
+];
+
+/// Spin types
+const SPINS: &[(&str, &str)] = &[
+    ("camel", "Camel spin (arabesque position)"),
+    ("sit", "Sit spin (sitting position)"),
+    ("upright", "Upright spin"),
+    ("layback", "Layback spin"),
+    ("biellmann", "Biellmann spin (leg held overhead)"),
+    ("combination", "Combination spin"),
+    ("flying", "Flying spin (jump entry)"),
+];
+
+/// Rotation qualifiers
+const ROTATIONS: &[(&str, &str)] = &[
+    ("single", "Single rotation"),
+    ("double", "Double rotation"),
+    ("triple", "Triple rotation"),
+    ("quad", "Quadruple rotation"),
+];
+
+/// Edge qualifiers
+const EDGES: &[(&str, &str)] = &[
+    ("inside", "Inside edge"),
+    ("outside", "Outside edge"),
+    ("forward", "Forward direction"),
+    ("backward", "Backward direction"),
+];
+
+pub async fn handle_completion(
+    _uri: &Url,
+    source: &str,
+    params: &CompletionParams,
+) -> Option<CompletionResponse> {
+    let position = params.text_document_position.position;
+    let context = get_context_at_position(source, position);
+
+    let mut items = Vec::new();
+
+    match context.as_str() {
+        "jump" => {
+            // Suggest jump types
+            for (name, detail) in JUMPS {
+                items.push(CompletionItem {
+                    label: name.to_string(),
+                    kind: Some(CompletionItemKind::ENUM_MEMBER),
+                    detail: Some(detail.to_string()),
+                    ..Default::default()
+                });
+            }
+            // Add rotation qualifiers
+            for (name, detail) in ROTATIONS {
+                items.push(CompletionItem {
+                    label: name.to_string(),
+                    kind: Some(CompletionItemKind::KEYWORD),
+                    detail: Some(detail.to_string()),
+                    ..Default::default()
+                });
+            }
+        }
+        "spin" => {
+            // Suggest spin types
+            for (name, detail) in SPINS {
+                items.push(CompletionItem {
+                    label: name.to_string(),
+                    kind: Some(CompletionItemKind::ENUM_MEMBER),
+                    detail: Some(detail.to_string()),
+                    ..Default::default()
+                });
+            }
+        }
+        _ => {
+            // Default: suggest all keywords
+            for (name, detail) in KEYWORDS {
+                items.push(CompletionItem {
+                    label: name.to_string(),
+                    kind: Some(CompletionItemKind::KEYWORD),
+                    detail: Some(detail.to_string()),
+                    ..Default::default()
+                });
+            }
+        }
+    }
+
+    Some(CompletionResponse::Array(items))
+}
+
+fn get_context_at_position(source: &str, position: Position) -> String {
+    let lines: Vec<&str> = source.lines().collect();
+    if position.line as usize >= lines.len() {
+        return String::new();
+    }
+
+    let line = lines[position.line as usize];
+    let before_cursor = &line[..position.character.min(line.len() as u32) as usize];
+
+    // Detect if we're after "jump" or "spin" keywords
+    if before_cursor.contains("jump") {
+        "jump".to_string()
+    } else if before_cursor.contains("spin") {
+        "spin".to_string()
+    } else {
+        String::new()
+    }
+}

crates/anv-lsp/src/handlers/definition.rs

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: MIT
+// Go-to-definition handler for Anvomidav LSP
+
+use tower_lsp::lsp_types::{GotoDefinitionParams, GotoDefinitionResponse, Location, Position, Range, Url};
+
+pub async fn handle_definition(
+    uri: &Url,
+    source: &str,
+    params: &GotoDefinitionParams,
+) -> Option<GotoDefinitionResponse> {
+    let position = params.text_document_position_params.position;
+    let word = get_word_at_position(source, position)?;
+
+    // Search for definition
+    let definition_location = find_definition(source, &word, uri)?;
+
+    Some(GotoDefinitionResponse::Scalar(definition_location))
+}
+
+fn get_word_at_position(source: &str, position: Position) -> Option<String> {
+    let lines: Vec<&str> = source.lines().collect();
+    if position.line as usize >= lines.len() {
+        return None;
+    }
+
+    let line = lines[position.line as usize];
+    let char_pos = position.character as usize;
+    if char_pos >= line.len() {
+        return None;
+    }
+
+    // Find word boundaries
+    let start = line[..char_pos]
+        .rfind(|c: char| !c.is_alphanumeric() && c != '_')
+        .map(|i| i + 1)
+        .unwrap_or(0);
+
+    let end = line[char_pos..]
+        .find(|c: char| !c.is_alphanumeric() && c != '_')
+        .map(|i| char_pos + i)
+        .unwrap_or(line.len());
+
+    Some(line[start..end].to_string())
+}
+
+fn find_definition(source: &str, target: &str, uri: &Url) -> Option<Location> {
+    // Search for definitions of segments, sequences, etc.
+    for (line_num, line) in source.lines().enumerate() {
+        // Match: "segment <name>:", "sequence <name> {", "program <name> {"
+        if let Some(pos) = line.find(target) {
+            // Check if this is a definition (has "segment", "sequence", "program" before it)
+            let before = &line[..pos];
+            if before.contains("segment ")
+                || before.contains("sequence ")
+                || before.contains("program ")
+                || before.contains("transition ")
+            {
+                return Some(Location {
+                    uri: uri.clone(),
+                    range: Range {
+                        start: Position {
+                            line: line_num as u32,
+                            character: pos as u32,
+                        },
+                        end: Position {
+                            line: line_num as u32,
+                            character: (pos + target.len()) as u32,
+                        },
+                    },
+                });
+            }
+        }
+    }
+
+    None
+}