partnercore-proxy 0.1.5 → 0.4.0

package/dist/al/language-server.js

@@ -3,7 +3,7 @@
  * AL Language Server Client
  *
  * Communicates with the Microsoft AL Language Server via LSP protocol.
- * Based on insights from Serena project's implementation.
+ * Provides full LSP integration for AL development.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -146,6 +146,91 @@ class ALLanguageServer {
                     publishDiagnostics: {
                         relatedInformation: true,
                     },
+                    codeAction: {
+                        dynamicRegistration: true,
+                        codeActionLiteralSupport: {
+                            codeActionKind: {
+                                valueSet: [
+                                    'quickfix',
+                                    'refactor',
+                                    'refactor.extract',
+                                    'refactor.inline',
+                                    'refactor.rewrite',
+                                    'source',
+                                    'source.organizeImports',
+                                ],
+                            },
+                        },
+                        resolveSupport: {
+                            properties: ['edit'],
+                        },
+                    },
+                    signatureHelp: {
+                        dynamicRegistration: true,
+                        signatureInformation: {
+                            documentationFormat: ['markdown', 'plaintext'],
+                            parameterInformation: {
+                                labelOffsetSupport: true,
+                            },
+                        },
+                        contextSupport: true,
+                    },
+                    formatting: {
+                        dynamicRegistration: true,
+                    },
+                    rangeFormatting: {
+                        dynamicRegistration: true,
+                    },
+                    onTypeFormatting: {
+                        dynamicRegistration: true,
+                    },
+                    documentHighlight: {
+                        dynamicRegistration: true,
+                    },
+                    foldingRange: {
+                        dynamicRegistration: true,
+                        foldingRangeKind: {
+                            valueSet: ['comment', 'imports', 'region'],
+                        },
+                    },
+                    selectionRange: {
+                        dynamicRegistration: true,
+                    },
+                    codeLens: {
+                        dynamicRegistration: true,
+                    },
+                    documentLink: {
+                        dynamicRegistration: true,
+                        tooltipSupport: true,
+                    },
+                    typeDefinition: {
+                        dynamicRegistration: true,
+                        linkSupport: true,
+                    },
+                    implementation: {
+                        dynamicRegistration: true,
+                        linkSupport: true,
+                    },
+                    semanticTokens: {
+                        dynamicRegistration: true,
+                        tokenTypes: [
+                            'namespace', 'type', 'class', 'enum', 'interface', 'struct',
+                            'typeParameter', 'parameter', 'variable', 'property', 'enumMember',
+                            'event', 'function', 'method', 'macro', 'keyword', 'modifier',
+                            'comment', 'string', 'number', 'regexp', 'operator', 'decorator',
+                        ],
+                        tokenModifiers: [
+                            'declaration', 'definition', 'readonly', 'static', 'deprecated',
+                            'abstract', 'async', 'modification', 'documentation', 'defaultLibrary',
+                        ],
+                        formats: ['relative'],
+                        requests: {
+                            full: true,
+                            range: true,
+                        },
+                        multilineTokenSupport: false,
+                        overlappingTokenSupport: false,
+                    },
                 },
                 workspace: {
                     applyEdit: true,
@@ -313,6 +398,269 @@ class ALLanguageServer {
         const result = await this.connection.sendRequest('workspace/symbol', { query });
         return result || [];
     }
+    /**
+     * Update document content (for editing)
+     */
+    async updateDocument(uri, content, version) {
+        if (!this.connection) {
+            throw new Error('Language server not initialized');
+        }
+        // If document is not open, open it first
+        if (!this.openDocuments.has(uri)) {
+            await this.openDocument(uri);
+        }
+        const params = {
+            textDocument: { uri, version },
+            contentChanges: [{ text: content }],
+        };
+        void this.connection.sendNotification('textDocument/didChange', params);
+        // Wait for diagnostics to be processed
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    /**
+     * Rename symbol across the workspace
+     * @returns WorkspaceEdit with all changes needed
+     */
+    async renameSymbol(uri, line, character, newName) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        // First, check if rename is valid
+        const prepareParams = {
+            textDocument: { uri },
+            position: { line, character },
+        };
+        try {
+            const prepareResult = await this.connection.sendRequest('textDocument/prepareRename', prepareParams);
+            if (!prepareResult) {
+                this.logger.debug('Rename not available at this position');
+                return null;
+            }
+            // Perform the rename
+            const renameParams = {
+                textDocument: { uri },
+                position: { line, character },
+                newName,
+            };
+            const result = await this.connection.sendRequest('textDocument/rename', renameParams);
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Rename failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Get the symbol at a specific position
+     */
+    async getSymbolAtPosition(uri, line, character) {
+        const symbols = await this.getDocumentSymbols(uri);
+        return this.findSymbolAtPosition(symbols, line, character);
+    }
+    /**
+     * Get code actions (quick fixes, refactorings) at a specific position or range
+     */
+    async getCodeActions(uri, range, context) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        // Build diagnostics with proper typing
+        const diagnostics = context?.diagnostics?.map(d => ({
+            message: d.message,
+            severity: this.severityToNumber(d.severity),
+            range: d.range,
+            code: d.code,
+            source: d.source,
+        })) || [];
+        const params = {
+            textDocument: { uri },
+            range,
+            context: {
+                diagnostics,
+                only: context?.only,
+            },
+        };
+        const result = await this.connection.sendRequest('textDocument/codeAction', params);
+        if (!result)
+            return [];
+        return result.map(item => {
+            // Check if it's a CodeAction (has 'title' as required field for both, but CodeAction has more fields)
+            const isCodeAction = 'kind' in item || 'edit' in item || ('command' in item && typeof item.command === 'object');
+            if (isCodeAction) {
+                const action = item;
+                let editResult;
+                if (action.edit && action.edit.changes) {
+                    editResult = {
+                        changes: action.edit.changes,
+                    };
+                }
+                return {
+                    title: action.title,
+                    kind: action.kind,
+                    isPreferred: action.isPreferred,
+                    edit: editResult,
+                    command: action.command ? {
+                        title: action.command.title,
+                        command: action.command.command,
+                        arguments: action.command.arguments,
+                    } : undefined,
+                };
+            }
+            else {
+                // It's a Command (simpler structure: title, command string, arguments)
+                const cmd = item;
+                return {
+                    title: cmd.title,
+                    command: {
+                        title: cmd.title,
+                        command: cmd.command,
+                        arguments: cmd.arguments,
+                    },
+                };
+            }
+        });
+    }
+    /**
+     * Get signature help (function parameter hints) at a position
+     */
+    async getSignatureHelp(uri, line, character, context) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+            context: context ? {
+                triggerKind: context.triggerKind || 1,
+                triggerCharacter: context.triggerCharacter,
+                isRetrigger: context.isRetrigger || false,
+            } : undefined,
+        };
+        const result = await this.connection.sendRequest('textDocument/signatureHelp', params);
+        if (!result)
+            return null;
+        return {
+            signatures: result.signatures.map(sig => ({
+                label: sig.label,
+                documentation: typeof sig.documentation === 'string'
+                    ? sig.documentation
+                    : sig.documentation?.value,
+                parameters: sig.parameters?.map(p => ({
+                    label: p.label,
+                    documentation: typeof p.documentation === 'string'
+                        ? p.documentation
+                        : p.documentation?.value,
+                })),
+            })),
+            activeSignature: result.activeSignature,
+            activeParameter: result.activeParameter,
+        };
+    }
+    /**
+     * Format an entire document
+     */
+    async formatDocument(uri, options) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const formattingOptions = {
+            tabSize: options?.tabSize ?? 4,
+            insertSpaces: options?.insertSpaces ?? true,
+        };
+        const params = {
+            textDocument: { uri },
+            options: formattingOptions,
+        };
+        const result = await this.connection.sendRequest('textDocument/formatting', params);
+        if (!result)
+            return [];
+        return result.map(edit => ({
+            range: {
+                start: { line: edit.range.start.line, character: edit.range.start.character },
+                end: { line: edit.range.end.line, character: edit.range.end.character },
+            },
+            newText: edit.newText,
+        }));
+    }
+    /**
+     * Format a range within a document
+     */
+    async formatRange(uri, range, options) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const formattingOptions = {
+            tabSize: options?.tabSize ?? 4,
+            insertSpaces: options?.insertSpaces ?? true,
+        };
+        const params = {
+            textDocument: { uri },
+            range,
+            options: formattingOptions,
+        };
+        const result = await this.connection.sendRequest('textDocument/rangeFormatting', params);
+        if (!result)
+            return [];
+        return result.map(edit => ({
+            range: {
+                start: { line: edit.range.start.line, character: edit.range.start.character },
+                end: { line: edit.range.end.line, character: edit.range.end.character },
+            },
+            newText: edit.newText,
+        }));
+    }
+    /**
+     * Convert severity string to LSP severity number
+     */
+    severityToNumber(severity) {
+        switch (severity) {
+            case 'error': return 1;
+            case 'warning': return 2;
+            case 'info': return 3;
+            case 'hint': return 4;
+            default: return 3;
+        }
+    }
+    /**
+     * Find symbol containing the given position
+     */
+    findSymbolAtPosition(symbols, line, character) {
+        for (const symbol of symbols) {
+            const { start, end } = symbol.range;
+            // Check if position is within this symbol's range
+            const isAfterStart = line > start.line || (line === start.line && character >= start.character);
+            const isBeforeEnd = line < end.line || (line === end.line && character <= end.character);
+            if (isAfterStart && isBeforeEnd) {
+                // Check children first (more specific match)
+                if (symbol.children) {
+                    const childMatch = this.findSymbolAtPosition(symbol.children, line, character);
+                    if (childMatch) {
+                        return childMatch;
+                    }
+                }
+                return symbol;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find a symbol by name in the document
+     */
+    async findSymbolByName(uri, symbolName) {
+        const symbols = await this.getDocumentSymbols(uri);
+        return this.searchSymbolByName(symbols, symbolName);
+    }
+    /**
+     * Search for symbol by name recursively
+     */
+    searchSymbolByName(symbols, name) {
+        for (const symbol of symbols) {
+            if (symbol.name.toLowerCase() === name.toLowerCase()) {
+                return symbol;
+            }
+            if (symbol.children) {
+                const found = this.searchSymbolByName(symbol.children, name);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
     /**
      * Convert LSP symbols to our format
      */
@@ -403,6 +751,333 @@ class ALLanguageServer {
             await this.initialize();
         }
     }
+    // ==================== Remaining LSP Features ====================
+    /**
+     * Close a document (cleanup)
+     */
+    async closeDocument(uri) {
+        await this.ensureInitialized();
+        if (!this.openDocuments.has(uri)) {
+            return; // Not open
+        }
+        const params = {
+            textDocument: { uri },
+        };
+        await this.connection.sendNotification('textDocument/didClose', params);
+        this.openDocuments.delete(uri);
+        this.diagnosticsCache.delete(uri);
+    }
+    /**
+     * Notify save (triggers recompile in some LSPs)
+     */
+    async saveDocument(uri, text) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            text,
+        };
+        await this.connection.sendNotification('textDocument/didSave', params);
+    }
+    /**
+     * Get document highlights (all occurrences of symbol under cursor)
+     */
+    async getDocumentHighlights(uri, line, character) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+        };
+        const result = await this.connection.sendRequest('textDocument/documentHighlight', params);
+        if (!result)
+            return [];
+        return result.map(h => ({
+            range: {
+                start: { line: h.range.start.line, character: h.range.start.character },
+                end: { line: h.range.end.line, character: h.range.end.character },
+            },
+            kind: h.kind === 1 ? 'text' : h.kind === 2 ? 'read' : h.kind === 3 ? 'write' : undefined,
+        }));
+    }
+    /**
+     * Get folding ranges (code regions, procedures, etc.)
+     */
+    async getFoldingRanges(uri) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+        };
+        const result = await this.connection.sendRequest('textDocument/foldingRange', params);
+        if (!result)
+            return [];
+        return result.map(r => ({
+            startLine: r.startLine,
+            startCharacter: r.startCharacter,
+            endLine: r.endLine,
+            endCharacter: r.endCharacter,
+            kind: r.kind,
+        }));
+    }
+    /**
+     * Get selection ranges (smart expand/shrink selection)
+     */
+    async getSelectionRanges(uri, positions) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            positions,
+        };
+        const result = await this.connection.sendRequest('textDocument/selectionRange', params);
+        if (!result)
+            return [];
+        const convertSelectionRange = (sr) => ({
+            range: {
+                start: { line: sr.range.start.line, character: sr.range.start.character },
+                end: { line: sr.range.end.line, character: sr.range.end.character },
+            },
+            parent: sr.parent ? convertSelectionRange(sr.parent) : undefined,
+        });
+        return result.map(convertSelectionRange);
+    }
+    /**
+     * Go to type definition (variable's type)
+     */
+    async getTypeDefinition(uri, line, character) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+        };
+        const result = await this.connection.sendRequest('textDocument/typeDefinition', params);
+        if (!result)
+            return [];
+        return Array.isArray(result) ? result : [result];
+    }
+    /**
+     * Go to implementation (interface implementations)
+     */
+    async getImplementation(uri, line, character) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+        };
+        const result = await this.connection.sendRequest('textDocument/implementation', params);
+        if (!result)
+            return [];
+        return Array.isArray(result) ? result : [result];
+    }
+    /**
+     * Format on type (format after specific character like ';')
+     */
+    async formatOnType(uri, line, character, ch, options) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+            ch,
+            options: {
+                tabSize: options?.tabSize ?? 4,
+                insertSpaces: options?.insertSpaces ?? true,
+            },
+        };
+        const result = await this.connection.sendRequest('textDocument/onTypeFormatting', params);
+        if (!result)
+            return [];
+        return result.map(edit => ({
+            range: {
+                start: { line: edit.range.start.line, character: edit.range.start.character },
+                end: { line: edit.range.end.line, character: edit.range.end.character },
+            },
+            newText: edit.newText,
+        }));
+    }
+    /**
+     * Get code lenses (inline hints like reference counts)
+     */
+    async getCodeLenses(uri) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+        };
+        const result = await this.connection.sendRequest('textDocument/codeLens', params);
+        if (!result)
+            return [];
+        return result.map(lens => ({
+            range: {
+                start: { line: lens.range.start.line, character: lens.range.start.character },
+                end: { line: lens.range.end.line, character: lens.range.end.character },
+            },
+            command: lens.command ? {
+                title: lens.command.title,
+                command: lens.command.command,
+                arguments: lens.command.arguments,
+            } : undefined,
+            data: lens.data,
+        }));
+    }
+    /**
+     * Resolve a code lens (get the command for a lens)
+     */
+    async resolveCodeLens(lens) {
+        await this.ensureInitialized();
+        const lspLens = {
+            range: {
+                start: { line: lens.range.start.line, character: lens.range.start.character },
+                end: { line: lens.range.end.line, character: lens.range.end.character },
+            },
+            data: lens.data,
+        };
+        const result = await this.connection.sendRequest('codeLens/resolve', lspLens);
+        return {
+            range: {
+                start: { line: result.range.start.line, character: result.range.start.character },
+                end: { line: result.range.end.line, character: result.range.end.character },
+            },
+            command: result.command ? {
+                title: result.command.title,
+                command: result.command.command,
+                arguments: result.command.arguments,
+            } : undefined,
+            data: result.data,
+        };
+    }
+    /**
+     * Get document links (clickable URLs in comments)
+     */
+    async getDocumentLinks(uri) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+        };
+        const result = await this.connection.sendRequest('textDocument/documentLink', params);
+        if (!result)
+            return [];
+        return result.map(link => ({
+            range: {
+                start: { line: link.range.start.line, character: link.range.start.character },
+                end: { line: link.range.end.line, character: link.range.end.character },
+            },
+            target: link.target,
+            tooltip: link.tooltip,
+        }));
+    }
+    /**
+     * Execute a command (e.g., from code action)
+     */
+    async executeCommand(command, args) {
+        await this.ensureInitialized();
+        const params = {
+            command,
+            arguments: args,
+        };
+        return this.connection.sendRequest('workspace/executeCommand', params);
+    }
+    /**
+     * Get semantic tokens (for syntax highlighting)
+     */
+    async getSemanticTokens(uri) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+        };
+        const result = await this.connection.sendRequest('textDocument/semanticTokens/full', params);
+        if (!result)
+            return null;
+        return {
+            resultId: result.resultId,
+            data: result.data,
+        };
+    }
+    /**
+     * Get semantic tokens for a range
+     */
+    async getSemanticTokensRange(uri, range) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const params = {
+            textDocument: { uri },
+            range,
+        };
+        const result = await this.connection.sendRequest('textDocument/semanticTokens/range', params);
+        if (!result)
+            return null;
+        return {
+            resultId: result.resultId,
+            data: result.data,
+        };
+    }
+    /**
+     * Restart the language server (useful when it hangs or after external changes)
+     */
+    async restart() {
+        this.logger.info('Restarting AL Language Server...');
+        await this.shutdown();
+        await this.initialize();
+        this.logger.info('AL Language Server restarted successfully');
+    }
+    /**
+     * Find all symbols that reference a given symbol (enhanced reference navigation)
+     * Returns referencing symbols with context around the reference
+     */
+    async findReferencingSymbols(uri, line, character, options) {
+        await this.ensureInitialized();
+        await this.openDocument(uri);
+        const contextBefore = options?.contextLinesBefore ?? 1;
+        const contextAfter = options?.contextLinesAfter ?? 1;
+        // Get all references
+        const params = {
+            textDocument: { uri },
+            position: { line, character },
+            context: { includeDeclaration: options?.includeDeclaration ?? false },
+        };
+        const locations = await this.connection.sendRequest('textDocument/references', params);
+        if (!locations || locations.length === 0) {
+            return [];
+        }
+        const results = [];
+        for (const loc of locations) {
+            const result = {
+                location: loc,
+            };
+            // Try to get the containing symbol
+            try {
+                const symbols = await this.getDocumentSymbols(loc.uri);
+                const containingSymbol = this.findSymbolAtPosition(symbols, loc.range.start.line, loc.range.start.character);
+                if (containingSymbol) {
+                    result.containingSymbol = containingSymbol;
+                }
+            }
+            catch {
+                // Ignore errors getting symbols
+            }
+            // Try to get context snippet
+            try {
+                const filePath = this.uriToPath(loc.uri);
+                if (fs.existsSync(filePath)) {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const lines = content.split('\n');
+                    const startLine = Math.max(0, loc.range.start.line - contextBefore);
+                    const endLine = Math.min(lines.length - 1, loc.range.start.line + contextAfter);
+                    result.contextSnippet = lines.slice(startLine, endLine + 1).join('\n');
+                }
+            }
+            catch {
+                // Ignore errors reading file
+            }
+            results.push(result);
+        }
+        return results;
+    }
     /**
      * Shutdown the language server
      */