refactor(vscode): some refactorings and code cleanup

Author: d-biehl

package.json

@@ -2012,11 +2012,11 @@
         }
       },
       {
-        "name": "robot-get_document_imports",
-        "displayName": "Get Document Imports",
+        "name": "robot-get_file_imports",
+        "displayName": "List imported libraries, resources and variable files for a Robot Framework Document",
         "toolReferenceName": "robotGetDocumentImports",
-        "modelDescription": "Retrieves a list of all imported libraries and resource files for a specific Robot Framework document. Returns the names and paths of all libraries imported in the specified Robot Framework file. Use this tool when you need to analyze the dependencies of a Robot Framework document or understand its library and resource usage. Limitations: Only works with Robot Framework files, may not detect dynamic imports or libraries loaded at runtime, and requires the specified file to be accessible from the workspace's Robot Framework configuration.",
-        "userDescription": "Gets a list of all imported libraries and resources for a specific Robot Framework document.",
+        "modelDescription": "Retrieves a list of all imported libraries, resources and variable files for a specific Robot Framework document. Returns the names and paths of all libraries imported in the specified Robot Framework file. Use this tool when you need to analyze the dependencies of a Robot Framework document or understand its library and resource usage. Limitations: Only works with Robot Framework files, may not detect dynamic imports or libraries loaded at runtime, and requires the specified file to be accessible from the workspace's Robot Framework configuration.",
+        "userDescription": "Gets a list of all imported libraries, resources and variable files for a specific Robot Framework document.",
         "canBeReferencedInPrompt": true,
         "tags": [
           "robot",
@@ -2044,7 +2044,7 @@
         "displayName": "Get Robot Framework Environment Informations",
         "toolReferenceName": "robotGetEnvironmentInfo",
         "modelDescription": "Retrieves detailed environment information for Robot Framework workspaces or files. Returns comprehensive details about the Python interpreter (version, executable path), installed Robot Framework version, RobotCode extension version, and optional tool versions (robocop, robotidy) if available. Use this tool when you need to diagnose environment issues, verify installations, check version compatibility, or troubleshoot Robot Framework setup problems. Limitations: Only provides information about the currently configured Python environment for the workspace, may not detect tools installed in different Python environments, requires proper workspace configuration to access environment details, and information accuracy depends on the current RobotCode language server connection.",
-        "userDescription": "Gets informations about the Robot Framework Environment.",
+        "userDescription": "Gets informations about the Robot Framework Environment .",
         "canBeReferencedInPrompt": true,
         "tags": [
           "robot",

vscode-client/extension/index.ts

@@ -163,7 +163,7 @@ export async function activateAsync(context: vscode.ExtensionContext): Promise<v
       new GetKeywordInfoTool(context, languageClientManger, outputChannel),
     ),
     vscode.lm.registerTool(
-      "robot-get_document_imports",
+      "robot-get_file_imports",
       new GetDocumentImportsTool(context, languageClientManger, outputChannel),
     ),
     vscode.lm.registerTool(

vscode-client/extension/languageclientsmanger.ts

@@ -27,6 +27,11 @@ import { getAvailablePort } from "./net_utils";
 const LANGUAGE_SERVER_DEFAULT_TCP_PORT = 6610;
 const LANGUAGE_SERVER_DEFAULT_HOST = "127.0.0.1";
 
+// Language Server Configuration Constants
+const CLIENT_DISPOSE_TIMEOUT = 5000;
+const CLIENT_SLEEP_DURATION = 500;
+const LANGUAGE_CLIENT_PREFIX = "$robotCode:";
+
 export function toVsCodeRange(range: Range): vscode.Range {
   return new vscode.Range(
     new vscode.Position(range.start.line, range.start.character),
@@ -146,39 +151,52 @@ export class LanguageClientsManager {
   }
 
   private _supportedLanguages?: string[];
+  private _fileExtensions?: string[];
 
-  public get supportedLanguages(): string[] {
-    if (this._supportedLanguages === undefined) {
-      this._supportedLanguages = ["robotframework"];
-
-      vscode.extensions.all.forEach((extension) => {
-        if (this._supportedLanguages !== undefined && extension.packageJSON !== undefined) {
-          const ext = (extension.packageJSON as RobotCodeContributions)?.contributes?.robotCode?.languageIds;
+  /**
+   * Invalidate cached extension data when extensions change
+   */
+  private invalidateExtensionCaches(): void {
+    this._supportedLanguages = undefined;
+    this._fileExtensions = undefined;
+  }
 
-          if (ext !== undefined) {
-            this._supportedLanguages.push(...ext);
-          }
+  /**
+   * Helper method to collect extension contributions from all VS Code extensions
+   */
+  private static collectExtensionContributions(
+    propertyPath: "languageIds" | "fileExtensions",
+    defaultValues: string[],
+  ): string[] {
+    const result: string[] = [...defaultValues];
+
+    vscode.extensions.all.forEach((extension) => {
+      if (extension.packageJSON) {
+        const ext = (extension.packageJSON as RobotCodeContributions)?.contributes?.robotCode?.[propertyPath];
+        if (ext !== undefined) {
+          result.push(...ext);
         }
-      });
+      }
+    });
+
+    return result;
+  }
+
+  public get supportedLanguages(): string[] {
+    if (this._supportedLanguages === undefined) {
+      this._supportedLanguages = LanguageClientsManager.collectExtensionContributions("languageIds", [
+        "robotframework",
+      ]);
     }
     return this._supportedLanguages;
   }
 
-  private _fileExtensions?: string[];
-
   public get fileExtensions(): string[] {
     if (this._fileExtensions === undefined) {
-      this._fileExtensions = ["robot", "resource"];
-
-      vscode.extensions.all.forEach((extension) => {
-        if (this._fileExtensions !== undefined && extension.packageJSON !== undefined) {
-          const ext = (extension.packageJSON as RobotCodeContributions)?.contributes?.robotCode?.fileExtensions;
-
-          if (ext !== undefined) {
-            this._fileExtensions.push(...ext);
-          }
-        }
-      });
+      this._fileExtensions = LanguageClientsManager.collectExtensionContributions("fileExtensions", [
+        "robot",
+        "resource",
+      ]);
     }
     return this._fileExtensions;
   }
@@ -195,8 +213,15 @@ export class LanguageClientsManager {
     fileWatcher1.onDidDelete((uri) => this.restart(vscode.workspace.getWorkspaceFolder(uri)?.uri));
     fileWatcher1.onDidChange((uri) => this.restart(vscode.workspace.getWorkspaceFolder(uri)?.uri));
 
+    // Listen for extension changes to invalidate caches
+    const extensionChangeListener = vscode.extensions.onDidChange(() => {
+      this.logger.debug("Extensions changed, invalidating caches");
+      this.invalidateExtensionCaches();
+    });
+
     this._disposables = vscode.Disposable.from(
       fileWatcher1,
+      extensionChangeListener,
 
       this.pythonManager.onActivePythonEnvironmentChanged(async (event) => {
         if (event.resource !== undefined) {
@@ -228,16 +253,37 @@ export class LanguageClientsManager {
     );
   }
 
+  private readonly logger = {
+    info: (message: string) => this.outputChannel.appendLine(`[INFO] ${message}`),
+    warn: (message: string) => this.outputChannel.appendLine(`[WARN] ${message}`),
+    error: (message: string) => this.outputChannel.appendLine(`[ERROR] ${message}`),
+    debug: (message: string) => this.outputChannel.appendLine(`[DEBUG] ${message}`),
+  };
+
   public async clearCaches(uri?: vscode.Uri): Promise<void> {
+    this.logger.info("Clearing language server caches...");
+
     if (uri !== undefined) {
       const client = await this.getLanguageClientForResource(uri);
       if (client) {
-        await client.sendRequest("robot/cache/clear");
+        try {
+          await client.sendRequest("robot/cache/clear");
+          this.logger.info(`Cache cleared for ${uri.toString()}`);
+        } catch (error) {
+          this.logger.error(`Failed to clear cache for ${uri.toString()}: ${error}`);
+        }
       }
     } else {
-      for (const client of this.clients.values()) {
-        await client.sendRequest("robot/cache/clear");
-      }
+      const clearPromises = Array.from(this.clients.values()).map(async (client) => {
+        try {
+          await client.sendRequest("robot/cache/clear");
+        } catch (error) {
+          this.logger.error(`Failed to clear cache for client: ${error}`);
+        }
+      });
+
+      await Promise.allSettled(clearPromises);
+      this.logger.info("Cache clearing completed for all clients");
     }
   }
 
@@ -248,9 +294,9 @@ export class LanguageClientsManager {
     this.clients.clear();
 
     for (const client of clients) {
-      promises.push(client.dispose(5000));
+      promises.push(client.dispose(CLIENT_DISPOSE_TIMEOUT));
     }
-    await sleep(500);
+    await sleep(CLIENT_SLEEP_DURATION);
 
     return Promise.all(promises).then(
       (r) => {
@@ -266,7 +312,7 @@ export class LanguageClientsManager {
   dispose(): void {
     this.stopAllClients().then(
       (_) => undefined,
-      (_) => undefined,
+      (error) => this.logger.error(`Error during dispose: ${error}`),
     );
     this._disposables.dispose();
   }
@@ -554,16 +600,15 @@ export class LanguageClientsManager {
 
       const clientOptions: LanguageClientOptions = {
         documentSelector:
-          // TODO: use SUPPORTED_LANGUAGES here
           vscode.workspace.workspaceFolders?.length === 1
-            ? [
-                { scheme: "file", language: "robotframework" },
-                { scheme: "untitled", language: "robotframework" },
-              ]
-            : [
-                { scheme: "file", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
-                { scheme: "untitled", language: "robotframework", pattern: `${workspaceFolder.uri.fsPath}/**/*` },
-              ],
+            ? this.supportedLanguages.flatMap((lang) => [
+                { scheme: "file", language: lang },
+                { scheme: "untitled", language: lang },
+              ])
+            : this.supportedLanguages.flatMap((lang) => [
+                { scheme: "file", language: lang, pattern: `${workspaceFolder.uri.fsPath}/**/*` },
+                { scheme: "untitled", language: lang, pattern: `${workspaceFolder.uri.fsPath}/**/*` },
+              ]),
         synchronize: {
           configurationSection: [CONFIG_SECTION],
         },
@@ -656,7 +701,12 @@ export class LanguageClientsManager {
       };
 
       this.outputChannel.appendLine(`create Language client: ${name}`);
-      result = new LanguageClient(`$robotCode:${workspaceFolder.uri.toString()}`, name, serverOptions, clientOptions);
+      result = new LanguageClient(
+        `${LANGUAGE_CLIENT_PREFIX}${workspaceFolder.uri.toString()}`,
+        name,
+        serverOptions,
+        clientOptions,
+      );
 
       this.outputChannel.appendLine(`trying to start Language client: ${name}`);
 
@@ -736,12 +786,12 @@ export class LanguageClientsManager {
         this.clients.delete(workspaceFolder.uri.toString());
 
         if (client) {
-          await client.dispose(5000);
-          await sleep(500);
+          await client.dispose(CLIENT_DISPOSE_TIMEOUT);
+          await sleep(CLIENT_SLEEP_DURATION);
         }
       } else {
         if (await this.stopAllClients()) {
-          await sleep(500);
+          await sleep(CLIENT_SLEEP_DURATION);
         }
       }
     });

vscode-client/extension/lmTools.tsx

@@ -78,7 +78,7 @@ export class GetLibraryInfoTool implements vscode.LanguageModelTool<GetLibraryIn
     }
 
     return {
-      invocationMessage: "Retrieving Robot Framework Library details",
+      invocationMessage: `Retrieving Robot Framework Library details for library: '${options.input.libraryName}'`,
     };
   }
 }
@@ -130,7 +130,7 @@ export class GetKeywordInfoTool implements vscode.LanguageModelTool<GetKeywordIn
   }
 
   async prepareInvocation?(
-    options: vscode.LanguageModelToolInvocationPrepareOptions<GetLibraryInfoToolParamters>,
+    options: vscode.LanguageModelToolInvocationPrepareOptions<GetKeywordInfoToolParamters>,
     _token: vscode.CancellationToken,
   ): Promise<vscode.PreparedToolInvocation> {
     const workspaceFolder = resolveWorkspaceFolder(options.input.resourcePath);
@@ -141,7 +141,7 @@ export class GetKeywordInfoTool implements vscode.LanguageModelTool<GetKeywordIn
     }
 
     return {
-      invocationMessage: "Retrieving Robot Framework Keyword details",
+      invocationMessage: `Retrieving Robot Framework Keyword details for keyword: '${options.input.keywordName}' from library: '${options.input.libraryName}'`,
     };
   }
 }
@@ -183,7 +183,7 @@ export class GetDocumentImportsTool implements vscode.LanguageModelTool<GetDocum
     }
 
     return {
-      invocationMessage: "Retrieving Robot Framework Document Imports",
+      invocationMessage: `Retrieving Robot Framework Document Imports for '${options.input.resourcePath}'`,
     };
   }
 }