@domainlang/language 0.7.0 → 0.9.0

package/src/lsp/hover/domain-lang-hover.ts

@@ -6,21 +6,29 @@ import type {
     MaybePromise,
     Reference
 } from 'langium';
-import { CstUtils, isReference } from 'langium';
+import { AstUtils, CstUtils, isReference } from 'langium';
 import type { LangiumServices } from 'langium/lsp';
 import { AstNodeHoverProvider } from 'langium/lsp';
 import type { Hover, HoverParams } from 'vscode-languageserver';
 import * as ast from '../../generated/ast.js';
 import type { DomainLangServices } from '../../domain-lang-module.js';
 import { QualifiedNameProvider } from '../domain-lang-naming.js';
+import type { DomainLangIndexManager } from '../domain-lang-index-manager.js';
 import { keywordExplanations } from './domain-lang-keywords.js';
-import { effectiveClassification, effectiveTeam } from '../../sdk/resolution.js';
+import {
+    buildDomainFields,
+    buildBcFields,
+    formatHoverContent,
+} from './hover-builders.js';
 
 /**
  * Type-specific hover content generator.
  * Returns undefined if the generator doesn't handle this node type.
+ * @param node - The AST node to generate hover content for
+ * @param commentBlock - Documentation comment block
+ * @param importAlias - Optional import alias if the node is from an imported document
  */
-type HoverContentGenerator = (node: AstNode, commentBlock: string) => string | undefined;
+type HoverContentGenerator = (node: AstNode, commentBlock: string, importAlias?: string) => string | undefined;
 
 /**
  * Provides hover information for DomainLang elements.
@@ -32,6 +40,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
     protected readonly documentationProvider: DocumentationProvider;
     protected readonly commentProvider: CommentProvider;
     protected readonly qualifiedNameProvider: QualifiedNameProvider;
+    protected readonly indexManager: DomainLangIndexManager;
 
     /**
      * Registry of type-specific hover content generators.
@@ -45,24 +54,25 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         this.commentProvider = services.documentation.CommentProvider;
         const domainServices = services as DomainLangServices;
         this.qualifiedNameProvider = domainServices.references.QualifiedNameProvider;
+        this.indexManager = services.shared.workspace.IndexManager as DomainLangIndexManager;
 
         // Register type-specific generators
         this.hoverGenerators = [
-            (node, comment) => this.getDomainHover(node, comment),
-            (node, comment) => this.getThisRefHover(node, comment),
-            (node, comment) => this.getBoundedContextHover(node, comment),
-            (node, comment) => this.getNamespaceHover(node, comment),
-            (node, comment) => this.getContextMapHover(node, comment),
-            (node, comment) => this.getDomainMapHover(node, comment),
-            (node, comment) => this.getDecisionHover(node, comment),
-            (node, comment) => this.getPolicyHover(node, comment),
-            (node, comment) => this.getBusinessRuleHover(node, comment),
-            (node, comment) => this.getDomainTermHover(node, comment),
-            (node, comment) => this.getTeamHover(node, comment),
-            (node, comment) => this.getClassificationHover(node, comment),
-            (node, comment) => this.getMetadataHover(node, comment),
-            (node, comment) => this.getRelationshipHover(node, comment),
-            (node, comment) => this.getImportHover(node, comment),
+            (node, comment, alias) => this.getDomainHover(node, comment, alias),
+            (node, comment, alias) => this.getThisRefHover(node, comment, alias),
+            (node, comment, alias) => this.getBoundedContextHover(node, comment, alias),
+            (node, comment, alias) => this.getNamespaceHover(node, comment, alias),
+            (node, comment, alias) => this.getContextMapHover(node, comment, alias),
+            (node, comment, alias) => this.getDomainMapHover(node, comment, alias),
+            (node, comment, alias) => this.getDecisionHover(node, comment, alias),
+            (node, comment, alias) => this.getPolicyHover(node, comment, alias),
+            (node, comment, alias) => this.getBusinessRuleHover(node, comment, alias),
+            (node, comment, alias) => this.getDomainTermHover(node, comment, alias),
+            (node, comment, alias) => this.getTeamHover(node, comment, alias),
+            (node, comment, alias) => this.getClassificationHover(node, comment, alias),
+            (node, comment, alias) => this.getMetadataHover(node, comment, alias),
+            (node, comment, alias) => this.getRelationshipHover(node, comment, alias),
+            (node, comment, alias) => this.getImportHover(node, comment, alias),
         ];
     }
 
@@ -80,13 +90,13 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
             }
 
             // Try declaration hover first
-            const declarationHover = await this.tryGetDeclarationHover(cstNode);
+            const declarationHover = await this.tryGetDeclarationHover(cstNode, document);
             if (declarationHover) {
                 return declarationHover;
             }
 
             // Then try keyword hover
-            return await this.tryGetKeywordHover(cstNode);
+            return this.tryGetKeywordHover(cstNode);
         } catch (error) {
             console.error('Error in getHoverContent:', error);
             return undefined;
@@ -95,21 +105,46 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
 
     /**
      * Try to get hover for a declaration node (AST node).
+     * For qualified name references, only shows hover when hovering over the last segment.
+     * For qualified name declarations (like namespace names), shows hover on any segment.
      */
-    private async tryGetDeclarationHover(cstNode: ReturnType<typeof CstUtils.findDeclarationNodeAtOffset>): Promise<Hover | undefined> {
+    private async tryGetDeclarationHover(
+        cstNode: ReturnType<typeof CstUtils.findDeclarationNodeAtOffset>,
+        document: LangiumDocument
+    ): Promise<Hover | undefined> {
         if (!cstNode) return undefined;
 
+        // For qualified name REFERENCES (e.g., "Core.Baunwalls.Jannie" in a BC classification),
+        // only show hover on the last segment. But for qualified name DECLARATIONS (like namespace names),
+        // show hover on any segment.
+        const isNamespaceDeclaration = ast.isNamespaceDeclaration(cstNode.astNode);
+        
+        if (!isNamespaceDeclaration) {
+            // This is a reference context - check if there's a dot immediately after this node
+            const fullText = document.textDocument.getText();
+            const nodeEndOffset = cstNode.offset + cstNode.length;
+            
+            // If the next non-whitespace character is a dot, this is not the last segment
+            if (nodeEndOffset < fullText.length) {
+                const nextChar = fullText.charAt(nodeEndOffset);
+                if (nextChar === '.') {
+                    // This node is followed by a dot, so it's not the last segment
+                    return undefined;
+                }
+            }
+        }
+
         const targetNodes = this.references.findDeclarations(cstNode);
         const targetNode = targetNodes?.[0];
         if (targetNode) {
-            const content = await this.getAstNodeHoverContent(targetNode);
+            const content = await this.getAstNodeHoverContent(targetNode, document);
             if (content) {
                 return { contents: { kind: 'markdown', value: content } };
             }
         }
 
         if (cstNode.astNode && ast.isThisRef(cstNode.astNode)) {
-            const content = await this.getAstNodeHoverContent(cstNode.astNode);
+            const content = await this.getAstNodeHoverContent(cstNode.astNode, document);
             if (content) {
                 return { contents: { kind: 'markdown', value: content } };
             }
@@ -122,7 +157,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
      * Try to get hover for a keyword node.
      * Uses the keyword dictionary for all keywords.
      */
-    private async tryGetKeywordHover(cstNode: ReturnType<typeof CstUtils.findDeclarationNodeAtOffset>): Promise<Hover | undefined> {
+    private tryGetKeywordHover(cstNode: ReturnType<typeof CstUtils.findDeclarationNodeAtOffset>): Hover | undefined {
         if (!cstNode || cstNode.grammarSource?.$type !== 'Keyword') {
             return undefined;
         }
@@ -136,54 +171,76 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return undefined;
     }
 
-    protected getAstNodeHoverContent(node: AstNode): MaybePromise<string | undefined> {
+    protected getAstNodeHoverContent(node: AstNode, currentDocument?: LangiumDocument): MaybePromise<string | undefined> {
         try {
             const content = this.documentationProvider.getDocumentation(node);
             const commentBlock = content ? `*${content}*\n\n` : '';
 
+            // Get import alias if the node is from an imported document
+            const importAlias = currentDocument ? this.getImportAliasForNode(node, currentDocument) : undefined;
+
             // Try each type-specific generator
             for (const generator of this.hoverGenerators) {
-                const result = generator(node, commentBlock);
+                const result = generator(node, commentBlock, importAlias);
                 if (result !== undefined) {
                     return result;
                 }
             }
 
             // Default fallback for unknown types
-            return this.getDefaultHover(node, commentBlock);
+            return this.getDefaultHover(node, commentBlock, importAlias);
         } catch (error) {
             console.error('Error in getAstNodeHoverContent:', error);
             return undefined;
         }
     }
 
+    /**
+     * Gets the import alias for a node if it's from an imported document.
+     * Returns undefined if the node is in the same document or not imported with an alias.
+     */
+    private getImportAliasForNode(targetNode: AstNode, currentDocument: LangiumDocument): string | undefined {
+        try {
+            const targetDoc = AstUtils.getDocument(targetNode);
+            const currentDocUri = currentDocument.uri.toString();
+            const targetDocUri = targetDoc.uri.toString();
+
+            // If same document, no alias needed
+            if (currentDocUri === targetDocUri) {
+                return undefined;
+            }
+
+            // Look up import info for the current document
+            const importInfo = this.indexManager.getImportInfo(currentDocUri);
+            
+            // Find the import that brings in the target document
+            for (const imp of importInfo) {
+                if (imp.resolvedUri === targetDocUri && imp.alias) {
+                    return imp.alias;
+                }
+            }
+
+            return undefined;
+        } catch (error) {
+            console.error('Error getting import alias for node:', error);
+            return undefined;
+        }
+    }
+
     // ============================================================
     // Type-specific hover generators
     // ============================================================
 
-    private getDomainHover(node: AstNode, commentBlock: string): string | undefined {
+    private getDomainHover(node: AstNode, commentBlock: string, importAlias?: string): string | undefined {
         if (!ast.isDomain(node)) return undefined;
 
-        const description = node.description ?? '';
-        const vision = node.vision ?? '';
-        const typeRef = node.type?.ref;
-        const type = this.getRefName(typeRef);
-
-        const signatureParts = ['Domain', node.name];
-        if (node.parent?.ref?.name) signatureParts.push('in', node.parent.ref.name);
-        const signature = this.codeBlock(signatureParts.join(' '));
-
-        const fields: string[] = [signature];
-        if (description) fields.push(description);
-        if (vision || type || node.parent) fields.push('---');
-        if (vision) fields.push(`**Vision:** ${vision}`);
-        if (type) fields.push(`**Type:** ${this.refLink(typeRef, type)}`);
-        if (node.parent) fields.push(`**Parent:** ${this.refLink(node.parent)}`);
-
-        return this.formatHover(commentBlock, '📁', 'domain', node.name, fields);
+        const displayName = this.getDisplayNameForHover(node, importAlias);
+        const refLink = (ref: ast.Type | undefined, label?: string): string => this.refLink(ref, label);
+        const fields = buildDomainFields(node, refLink);
+        return formatHoverContent(commentBlock, '📁', 'domain', displayName, fields);
     }
 
-    private getThisRefHover(node: AstNode, _commentBlock: string): string | undefined {
+    private getThisRefHover(node: AstNode, _commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isThisRef(node)) return undefined;
 
         let parent = node.$container;
@@ -196,7 +253,17 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
                 ast.isDomainMap(parent) ||
                 ast.isModel(parent)
             ) {
-                return this.getAstNodeHoverContent(parent) as string | undefined;
+                const result = this.getAstNodeHoverContent(parent);
+                // getAstNodeHoverContent returns MaybePromise<string | undefined>.
+                // All registered hover generators are synchronous, so the result
+                // should always be a plain string. Guard defensively in case a
+                // future generator becomes async.
+                if (typeof result === 'string' || result === undefined) {
+                    return result;
+                }
+                // If somehow a Promise is returned, we cannot await in a sync
+                // context - fall through to the default message.
+                return undefined;
             }
             parent = parent.$container;
         }
@@ -204,58 +271,27 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return '*this* refers to the current context';
     }
 
-    private getBoundedContextHover(node: AstNode, commentBlock: string): string | undefined {
+    private getBoundedContextHover(node: AstNode, commentBlock: string, importAlias?: string): string | undefined {
         if (!ast.isBoundedContext(node)) return undefined;
 
-        const description = node.description ?? '';
-        const classification = effectiveClassification(node);
-        const team = effectiveTeam(node);
-        const businessModel = node.businessModel?.ref;
-        const evolution = node.evolution?.ref;
-        const relationships = node.relationships ?? [];
-        const terminology = node.terminology ?? [];
-        const decisions = node.decisions ?? [];
-        const classificationName = classification?.name;
-        const teamName = team?.name;
-
-        const signatureParts = ['boundedcontext', node.name];
-        if (node.domain?.ref?.name) signatureParts.push('for', node.domain.ref.name);
-        if (classificationName) signatureParts.push('as', classificationName);
-        if (teamName) signatureParts.push('by', teamName);
-        const signature = this.codeBlock(signatureParts.join(' '));
-
-        const fields: string[] = [signature];
-        if (description) fields.push(description);
-        if (classification || team || businessModel || evolution) fields.push('---');
-        if (classification) fields.push(`🔖 **Classification:** ${this.refLink(classification)}`);
-        if (team) fields.push(`👥 **Team:** ${this.refLink(team)}`);
-        if (businessModel) fields.push(`💼 **Business Model:** ${this.refLink(businessModel)}`);
-        if (evolution) fields.push(`🔄 **Evolution:** ${this.refLink(evolution)}`);
-
-        if (relationships.length > 0) {
-            const lines = relationships.map(rel => this.formatRelationshipLine(rel));
-            fields.push(`**Relationships:**\n${lines.join('\n')}`);
-        }
-        if (terminology.length > 0) {
-            const lines = terminology.map(t => `- \`${t.name}\`: ${t.meaning ?? ''}`);
-            fields.push(`**Terminology:**\n${lines.join('\n')}`);
-        }
-        if (decisions.length > 0) {
-            const lines = decisions.map(d => `- \`${d.name}\`: ${d.value ?? ''}`);
-            fields.push(`**Decisions:**\n${lines.join('\n')}`);
-        }
-
-        return this.formatHover(commentBlock, '📕', 'boundedcontext', node.name, fields);
+        const displayName = this.getDisplayNameForHover(node, importAlias);
+        const refLink = (ref: ast.Type | undefined, label?: string): string => this.refLink(ref, label);
+        const fields = buildBcFields(
+            node,
+            refLink,
+            (rel) => this.formatRelationshipLine(rel)
+        );
+        return formatHoverContent(commentBlock, '🎯', 'bounded context', displayName, fields);
     }
 
-    private getNamespaceHover(node: AstNode, commentBlock: string): string | undefined {
+    private getNamespaceHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isNamespaceDeclaration(node)) return undefined;
 
         const fields: string[] = [`Contains ${node.children.length} elements.`];
         return this.formatHover(commentBlock, '🧭', 'namespace', node.name, fields);
     }
 
-    private getContextMapHover(node: AstNode, commentBlock: string): string | undefined {
+    private getContextMapHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isContextMap(node)) return undefined;
 
         const fields: string[] = [];
@@ -274,7 +310,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '🗺️', 'contextmap', node.name, fields);
     }
 
-    private getDomainMapHover(node: AstNode, commentBlock: string): string | undefined {
+    private getDomainMapHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isDomainMap(node)) return undefined;
 
         const fields: string[] = [];
@@ -288,7 +324,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '🗺️', 'domainmap', node.name, fields);
     }
 
-    private getDecisionHover(node: AstNode, commentBlock: string): string | undefined {
+    private getDecisionHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isDecision(node)) return undefined;
 
         const fields: string[] = [];
@@ -298,7 +334,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '⚖️', 'decision', node.name, fields);
     }
 
-    private getPolicyHover(node: AstNode, commentBlock: string): string | undefined {
+    private getPolicyHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isPolicy(node)) return undefined;
 
         const fields: string[] = [];
@@ -308,7 +344,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '📜', 'policy', node.name, fields);
     }
 
-    private getBusinessRuleHover(node: AstNode, commentBlock: string): string | undefined {
+    private getBusinessRuleHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isBusinessRule(node)) return undefined;
 
         const fields: string[] = [];
@@ -318,7 +354,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '⚖️', 'rule', node.name, fields);
     }
 
-    private getDomainTermHover(node: AstNode, commentBlock: string): string | undefined {
+    private getDomainTermHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isDomainTerm(node)) return undefined;
 
         const fields: string[] = [];
@@ -328,22 +364,25 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '🗝️', 'term', node.name, fields);
     }
 
-    private getTeamHover(node: AstNode, commentBlock: string): string | undefined {
+    private getTeamHover(node: AstNode, commentBlock: string, importAlias?: string): string | undefined {
         if (!ast.isTeam(node)) return undefined;
-        return this.formatHover(commentBlock, '👥', 'team', node.name, []);
+        const displayName = this.getDisplayNameForHover(node, importAlias);
+        return this.formatHover(commentBlock, '👥', 'team', displayName, []);
     }
 
-    private getClassificationHover(node: AstNode, commentBlock: string): string | undefined {
+    private getClassificationHover(node: AstNode, commentBlock: string, importAlias?: string): string | undefined {
         if (!ast.isClassification(node)) return undefined;
-        return this.formatHover(commentBlock, '🏷️', 'classification', node.name, []);
+        const displayName = this.getDisplayNameForHover(node, importAlias);
+        return this.formatHover(commentBlock, '🏷️', 'classification', displayName, []);
     }
 
-    private getMetadataHover(node: AstNode, commentBlock: string): string | undefined {
+    private getMetadataHover(node: AstNode, commentBlock: string, importAlias?: string): string | undefined {
         if (!ast.isMetadata(node)) return undefined;
-        return this.formatHover(commentBlock, '🔖', 'metadata', node.name, []);
+        const displayName = this.getDisplayNameForHover(node, importAlias);
+        return this.formatHover(commentBlock, '🔖', 'metadata', displayName, []);
     }
 
-    private getRelationshipHover(node: AstNode, commentBlock: string): string | undefined {
+    private getRelationshipHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isRelationship(node)) return undefined;
 
         const leftPatterns = node.leftPatterns.join(', ');
@@ -358,7 +397,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '🔗', 'relationship', undefined, fields);
     }
 
-    private getImportHover(node: AstNode, commentBlock: string): string | undefined {
+    private getImportHover(node: AstNode, commentBlock: string, _importAlias?: string): string | undefined {
         if (!ast.isImportStatement(node)) return undefined;
 
         const fields: string[] = [`**URI:** \`${node.uri}\``];
@@ -366,7 +405,7 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return this.formatHover(commentBlock, '📦', 'import', undefined, fields);
     }
 
-    private getDefaultHover(node: AstNode, commentBlock: string): string {
+    private getDefaultHover(node: AstNode, commentBlock: string, _importAlias?: string): string {
         const title = ast.isType(node) ? node.name : node.$type.toLowerCase();
         const typeName = node.$type.toLowerCase();
         const name = ast.isType(node) ? ` ${title}` : '';
@@ -379,6 +418,21 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
     // Helper methods
     // ============================================================
 
+    /**
+     * Computes the display name for a node in hover, considering import aliases.
+     * If node is imported with an alias, shows `alias.name`, otherwise shows full qualified name.
+     */
+    private getDisplayNameForHover(node: ast.Type, importAlias?: string): string {
+        if (importAlias) {
+            return `${importAlias}.${node.name}`;
+        }
+        try {
+            return this.qualifiedNameProvider.getQualifiedName(node.$container, node.name);
+        } catch {
+            return node.name;
+        }
+    }
+
     /**
      * Formats a relationship line for hover display.
      */
@@ -389,15 +443,9 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         return `- ${left} ${rel.arrow} ${right}${type}`;
     }
 
-    /**
-     * Wraps text in a domain-lang code block.
-     */
-    private codeBlock(text: string): string {
-        return `\`\`\`domain-lang\n${text}\n\`\`\``;
-    }
-
     /**
      * Formats the final hover content with consistent structure.
+     * Delegates to the shared hover-builders utility.
      */
     private formatHover(
         commentBlock: string,
@@ -406,38 +454,48 @@ export class DomainLangHoverProvider extends AstNodeHoverProvider {
         name: string | undefined,
         fields: string[]
     ): string {
-        const separator = commentBlock ? `${commentBlock}\n\n---\n\n` : '';
-        const nameDisplay = name ? ` ${name}` : '';
-        const header = `${emoji} **\`(${typeName})\`${nameDisplay}**`;
-        const body = fields.length > 0 ? `\n\n${fields.join('\n\n')}` : '';
-        return `${separator}${header}${body}`;
+        return formatHoverContent(commentBlock, emoji, typeName, name, fields);
     }
 
-    private getRefName(ref: ast.Type | Reference<ast.Type> | undefined): string {
+    private refLink(ref: Reference<ast.Type> | ast.Type | undefined, label?: string): string {
         const node = isReference(ref) ? ref.ref : ref;
-        if (node && ast.isType(node)) {
-            return node.name;
-        }
-        return '';
-    }
 
-    private refLink(ref: Reference<ast.Type> | ast.Type | undefined, label?: string): string {
-        if (label) {
-            return `[${label}](#${encodeURIComponent(label)})`;
+        if (!node || !ast.isType(node)) {
+            return label ? `\`${label}\`` : '';
         }
 
-        const node = isReference(ref) ? ref.ref : ref;
-
-        if (node && ast.isType(node)) {
-            let linkLabel = node.name;
+        // Get display name (use label if provided, otherwise qualified name)
+        let linkLabel: string;
+        if (label) {
+            linkLabel = label;
+        } else {
             try {
                 linkLabel = this.qualifiedNameProvider.getQualifiedName(node.$container, node.name);
             } catch {
-                // fallback to name
+                linkLabel = node.name;
             }
-            return `[${linkLabel}](#${encodeURIComponent(linkLabel)})`;
         }
-        return '';
+
+        // Try to create clickable go-to-definition link
+        try {
+            const doc = AstUtils.getDocument(node);
+            const cstNode = node.$cstNode;
+            
+            if (doc && cstNode) {
+                const range = CstUtils.toDocumentSegment(cstNode).range;
+                const line = range.start.line + 1; // LSP lines are 0-indexed, file links use 1-indexed
+                const col = range.start.character + 1;
+                const uri = doc.uri.toString();
+                
+                // VS Code recognizes file:// URIs with #Lline,col for go-to-definition
+                return `[${linkLabel}](${uri}#L${line},${col})`;
+            }
+        } catch (error) {
+            console.error('Error creating hover link:', error);
+        }
+
+        // Fallback to plain text if we can't create a link
+        return `\`${linkLabel}\``;
     }
 
 }