diff --git a/.vscode/settings.json b/.vscode/settings.json index dfa4f547b..19a91f870 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -35,5 +35,8 @@ ], "typescript.updateImportsOnFileMove.enabled": "always", "workbench.editor.enablePreview": true, - "iis.configDir": "" + "iis.configDir": "", + "idf.pythonInstallPath": "/opt/homebrew/bin/python3", + "idf.espIdfPath": "/Users/radurentea/esp/v5.4/esp-idf", + "idf.toolsPath": "/Users/radurentea/esp/esptools" } diff --git a/l10n/bundle.l10n.es.json b/l10n/bundle.l10n.es.json index 06572d418..bc781450a 100644 --- a/l10n/bundle.l10n.es.json +++ b/l10n/bundle.l10n.es.json @@ -207,5 +207,11 @@ "Warning: Could not fully remove setting {0}: {1}": "Advertencia: No se pudo eliminar completamente la configuración {0}: {1}", "ESP-IDF settings removed successfully.": "Configuraciones de ESP-IDF eliminadas exitosamente.", "Failed to remove settings: {0}": "Error al eliminar las configuraciones: {0}", - "Error: {0}": "Error: {0}" + "Error: {0}": "Error: {0}", + "🔗 Reference Documentation": "🔗 Documentación de Referencia", + "Open {0}": "Abrir {0}", + "💡 Show Hints": "💡 Mostrar Pistas", + "Mute for this session": "Silenciar para esta sesión", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Notificaciones de pistas silenciadas para esta sesión. Todavía puede acceder a las pistas manualmente en el panel inferior de ESP-IDF", + "Possible hint found for the error: {0}": "Posible pista encontrada para el error: {0}" } diff --git a/l10n/bundle.l10n.pt.json b/l10n/bundle.l10n.pt.json index 5dfb64f34..327c903c2 100644 --- a/l10n/bundle.l10n.pt.json +++ b/l10n/bundle.l10n.pt.json @@ -207,5 +207,11 @@ "Warning: Could not fully remove setting {0}: {1}": "Aviso: Não foi possível remover completamente a configuração {0}: {1}", "ESP-IDF settings removed successfully.": "Configurações ESP-IDF removidas com sucesso.", "Failed to remove settings: {0}": "Falha ao remover configurações: {0}", - "Error: {0}": "Erro: {0}" + "Error: {0}": "Erro: {0}", + "🔗 Reference Documentation": "🔗Documentação de Referência", + "Open {0}": "Abrir {0}", + "💡 Show Hints": "💡 Mostrar Dicas", + "Mute for this session": "Silenciar para esta sessão", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Notificações de dicas silenciadas para esta sessão. Você ainda pode acessar dicas manualmente no painel inferior do ESP-IDF", + "Possible hint found for the error: {0}": "Possível dica encontrada para o erro: {0}" } diff --git a/l10n/bundle.l10n.ru.json b/l10n/bundle.l10n.ru.json index 48cd8e27e..dfc27e485 100644 --- a/l10n/bundle.l10n.ru.json +++ b/l10n/bundle.l10n.ru.json @@ -207,5 +207,11 @@ "Warning: Could not fully remove setting {0}: {1}": "Предупреждение: Не удалось полностью удалить настройку {0}: {1}", "ESP-IDF settings removed successfully.": "Настройки ESP-IDF успешно удалены.", "Failed to remove settings: {0}": "Не удалось удалить настройки: {0}", - "Error: {0}": "Ошибка: {0}" + "Error: {0}": "Ошибка: {0}", + "🔗 Reference Documentation": "🔗 Справочная Документация", + "Open {0}": "Открыть {0}", + "💡 Show Hints": "💡 Показать Подсказки", + "Mute for this session": "Отключить звук для этой сессии", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "Уведомления с подсказками отключены для этой сессии. Вы все еще можете получить доступ к подсказкам вручную в нижней панели ESP-IDF", + "Possible hint found for the error: {0}": "Возможная подсказка найдена для ошибки: {0}" } diff --git a/l10n/bundle.l10n.zh-CN.json b/l10n/bundle.l10n.zh-CN.json index a60713862..5722b99f8 100644 --- a/l10n/bundle.l10n.zh-CN.json +++ b/l10n/bundle.l10n.zh-CN.json @@ -207,5 +207,11 @@ "Warning: Could not fully remove setting {0}: {1}": "警告：无法完全删除设置 {0}：{1}", "ESP-IDF settings removed successfully.": "ESP-IDF设置已成功删除。", "Failed to remove settings: {0}": "删除设置失败：{0}", - "Error: {0}": "错误：{0}" + "Error: {0}": "错误：{0}", + "🔗 Reference Documentation": "🔗 参考文档", + "Open {0}": "打开 {0}", + "💡 Show Hints": "💡 显示提示", + "Mute for this session": "为本次会话静音", + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel": "本次会话的提示通知已静音。您仍然可以在 ESP-IDF 底部面板中手动访问提示", + "Possible hint found for the error: {0}": "已找到可能的错误提示：{0}" } diff --git a/package.json b/package.json index 4a77b2de4..91a8ea427 100644 --- a/package.json +++ b/package.json @@ -277,7 +277,8 @@ "column": 3, "severity": 4, "message": 5 - } + }, + "source": "esp-idf" }, { "name": "espIdfLd", @@ -292,7 +293,8 @@ "file": 1, "line": 2, "message": 3 - } + }, + "source": "esp-idf" } ], "viewsContainers": { @@ -314,9 +316,9 @@ "views": { "espIdfHints": [ { - "id": "errorHints", + "id": "idfErrorHints", "name": "Error Hints", - "title": "Error Hints ($errorHints.count$)" + "title": "Error Hints ($idfErrorHints.count$)" } ], "debug": [ @@ -398,10 +400,15 @@ } ], "view/title": [ + { + "command": "espIdf.errorHints.clearAll", + "when": "view == idfErrorHints", + "group": "navigation" + }, { "command": "espIdf.searchError", "group": "navigation", - "when": "view == errorHints" + "when": "view == idfErrorHints" }, { "command": "espIdf.partition.table.refresh", @@ -444,6 +451,14 @@ } ], "view/item/context": [ + { + "command": "espIdf.errorHints.clearBuildErrors", + "when": "view == idfErrorHints && viewItem == buildError" + }, + { + "command": "espIdf.errorHints.clearOpenOCDErrors", + "when": "view == idfErrorHints && viewItem == openocdError" + }, { "command": "esp.rainmaker.backend.logout", "when": "view == espRainmaker && viewItem == account", @@ -1199,6 +1214,24 @@ } ], "commands": [ + { + "command": "espIdf.errorHints.clearAll", + "title": "Clear All Error Hints", + "icon": "$(clear-all)", + "category": "ESP-IDF" + }, + { + "command": "espIdf.errorHints.clearBuildErrors", + "title": "Clear Build Error Hints", + "icon": "$(trash)", + "category": "ESP-IDF" + }, + { + "command": "espIdf.errorHints.clearOpenOCDErrors", + "title": "Clear OpenOCD Error Hints", + "icon": "$(trash)", + "category": "ESP-IDF" + }, { "command": "espIdf.removeEspIdfSettings", "title": "%espIdf.removeEspIdfSettings.title%", @@ -1206,11 +1239,13 @@ }, { "command": "espIdf.openWalkthrough", - "title": "ESP-IDF: Open Get Started Walkthrough" + "title": "ESP-IDF: Open Get Started Walkthrough", + "category": "ESP-IDF" }, { "command": "espIdf.searchError", - "title": "%espIdf.searchError.title%" + "title": "%espIdf.searchError.title%", + "category": "ESP-IDF" }, { "command": "espIdf.createFiles", diff --git a/src/espIdf/hints/index.ts b/src/espIdf/hints/index.ts index dee8c2028..c9a885f58 100644 --- a/src/espIdf/hints/index.ts +++ b/src/espIdf/hints/index.ts @@ -1,66 +1,183 @@ -import * as os from "os"; +// Copyright 2025 Espressif Systems (Shanghai) CO LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + import * as yaml from "js-yaml"; import { readFile, pathExists } from "fs-extra"; import * as idfConf from "../../idfConfiguration"; import { Logger } from "../../logger/logger"; import * as utils from "../../utils"; import * as vscode from "vscode"; - -class ReHintPair { - re: string; - hint: string; - match_to_output: boolean; - - constructor(re: string, hint: string, match_to_output: boolean = false) { +import * as path from "path"; +import { OpenOCDManager } from "../openOcd/openOcdManager"; + +/** + * Class representing a pair of regular expression and its corresponding hint. + * Used to match error messages and provide helpful guidance. + */ +class ReHintPair { + re: string; // Regular expression to match error messages + hint: string; // Hint text to show when the regex matches + match_to_output: boolean; // Whether to insert matched groups into the hint + ref?: string; // Link to documentation for openOCD hints + + constructor( + re: string, + hint: string, + match_to_output: boolean = false, + ref?: string + ) { this.re = re; this.hint = hint; this.match_to_output = match_to_output; + this.ref = ref; } } -class ErrorHint { - public type: "error" | "hint"; - public children: ErrorHint[] = []; - - constructor(public label: string, type: "error" | "hint") { - this.type = type; - } +export class ErrorHintTreeItem extends vscode.TreeItem { + constructor( + public readonly label: string, + public readonly type: "error" | "hint" | "reference", + public readonly children: ErrorHintTreeItem[] = [], + public readonly reference?: string + ) { + super( + label, + children.length > 0 + ? vscode.TreeItemCollapsibleState.Expanded + : vscode.TreeItemCollapsibleState.None + ); - addChild(child: ErrorHint) { - this.children.push(child); + // Set different appearances based on the type + if (type === "error") { + if (label.startsWith("No hints found")) { + this.label = `⚠️ ${label}`; + } else { + this.label = `🔍 ${label}`; + } + } else if (type === "hint") { + this.label = `💡 ${label}`; + this.tooltip = label; + } else if (type === "reference") { + this.label = vscode.l10n.t(`🔗 Reference Documentation`); + this.tooltip = vscode.l10n.t(`Open {0}`, label); + this.command = { + command: 'vscode.open', + title: 'Open Reference', + arguments: [vscode.Uri.parse(label)] + }; + this.iconPath = new vscode.ThemeIcon("link-external"); + } } } -export class ErrorHintProvider implements vscode.TreeDataProvider { - constructor(private context: vscode.ExtensionContext) {} +export class ErrorHintProvider implements vscode.TreeDataProvider { private _onDidChangeTreeData: vscode.EventEmitter< - ErrorHint | undefined | null | void - > = new vscode.EventEmitter(); + ErrorHintTreeItem | undefined | null | void + > = new vscode.EventEmitter(); + readonly onDidChangeTreeData: vscode.Event< - ErrorHint | undefined | null | void + ErrorHintTreeItem | undefined | null | void > = this._onDidChangeTreeData.event; - private data: ErrorHint[] = []; + private buildErrorData: ErrorHintTreeItem[] = []; + private openocdErrorData: ErrorHintTreeItem[] = []; + + constructor(private context: vscode.ExtensionContext) {} + + // Get tree item for display + getTreeItem(element: ErrorHintTreeItem): vscode.TreeItem { + return element; + } + + // Get children of a tree item + getChildren(element?: ErrorHintTreeItem): Thenable { + if (element) { + return Promise.resolve(element.children); + } else { + return Promise.resolve([...this.buildErrorData, ...this.openocdErrorData]); + } + } + + // Clear error hints + clearErrorHints(clearOpenOCD: boolean = false): void { + this.buildErrorData = []; + if (clearOpenOCD) { + this.openocdErrorData = []; + } + this._onDidChangeTreeData.fire(); + } - public getHintForError(errorMsg: string): string | undefined { - for (const errorHint of this.data) { - if (errorHint.label.includes(errorMsg) && errorHint.children.length > 0) { - return errorHint.children[0].label; + // Clear only OpenOCD errors + clearOpenOCDErrorsOnly(): void { + this.openocdErrorData = []; + this._onDidChangeTreeData.fire(); + } + + // Show OpenOCD error hint + public async showOpenOCDErrorHint( + errorMsg: string, + hintMsg: string, + reference?: string + ): Promise { + try { + this.openocdErrorData = []; + + // Create hint nodes + const hintItems: ErrorHintTreeItem[] = []; + + // Add reference as a child if available + if (reference) { + hintItems.push(new ErrorHintTreeItem(reference, "reference")); } + + // Create hint with children + const hint = new ErrorHintTreeItem(hintMsg, "hint", hintItems); + + // Create error with hint as child + const error = new ErrorHintTreeItem(errorMsg, "error", [hint]); + + // Add to OpenOCD data array + this.openocdErrorData.push(error); + + // Notify that the tree data has changed + this._onDidChangeTreeData.fire(); + + return true; + } catch (error) { + Logger.errorNotify( + `Error showing OpenOCD error hint: ${error.message}`, + error, + "ErrorHintProvider showOpenOCDErrorHint" + ); + return false; } - return undefined; } - async searchError(errorMsg: string, workspace): Promise { + // Method to search for error hints + public async searchError(errorMsg: string, workspace: vscode.Uri): Promise { + this.buildErrorData = []; + const espIdfPath = idfConf.readParameter( "idf.espIdfPath", workspace ) as string; + const version = await utils.getEspIdfFromCMake(espIdfPath); if (utils.compareVersion(version.trim(), "5.0") === -1) { - this.data.push( - new ErrorHint( + this.buildErrorData.push( + new ErrorHintTreeItem( `Error hints feature is not supported in ESP-IDF version ${version}`, "error" ) @@ -69,73 +186,60 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return false; } - const hintsPath = getHintsYmlPath(espIdfPath); + // Get paths for both hint files + const idfHintsPath = getIdfHintsYmlPath(espIdfPath); + const openOcdHintsPath = await getOpenOcdHintsYmlPath(workspace); try { - if (!(await pathExists(hintsPath))) { - Logger.infoNotify(`${hintsPath} does not exist.`); - return false; - } - - const fileContents = await readFile(hintsPath, "utf-8"); - const hintsData = yaml.load(fileContents); - - const reHintsPairArray: ReHintPair[] = this.loadHints(hintsData); - - this.data = []; let meaningfulHintFound = false; - for (const hintPair of reHintsPairArray) { - const match = new RegExp(hintPair.re, "i").exec(errorMsg); - const regexParts = Array.from(hintPair.re.matchAll(/\(([^)]+)\)/g)) - .map((m) => m[1].split("|")) - .flat() - .map((part) => part.toLowerCase()); - if ( - match || - regexParts.some((part) => errorMsg.toLowerCase().includes(part)) - ) { - let finalHint = hintPair.hint; - if ( - match && - hintPair.match_to_output && - hintPair.hint.includes("{}") - ) { - finalHint = hintPair.hint.replace("{}", match[0]); - } else if (!match && hintPair.hint.includes("{}")) { - const matchedSubstring = regexParts.find((part) => - errorMsg.toLowerCase().includes(part.toLowerCase()) - ); - finalHint = hintPair.hint.replace("{}", matchedSubstring || ""); // Handle case where nothing is matched - } - const error = new ErrorHint(errorMsg, "error"); - const hint = new ErrorHint(finalHint, "hint"); - error.addChild(hint); - this.data.push(error); - if (!finalHint.startsWith("No hints found for")) { - meaningfulHintFound = true; - } + // Process ESP-IDF hints + if (await pathExists(idfHintsPath)) { + try { + const fileContents = await readFile(idfHintsPath, "utf-8"); + const hintsData = yaml.load(fileContents) as []; + const reHintsPairArray: ReHintPair[] = this.loadHints(hintsData); + + meaningfulHintFound = + (await this.processHints(errorMsg, reHintsPairArray)) || + meaningfulHintFound; + } catch (error) { + Logger.errorNotify( + `Error processing ESP-IDF hints file (line ${error.mark?.line}): ${error.message}`, + error, + "ErrorHintProvider searchError" + ); } + } else { + Logger.infoNotify(`${idfHintsPath} does not exist.`); } - if (this.data.length === 0) { - for (const hintPair of reHintsPairArray) { - if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { - const error = new ErrorHint(hintPair.re, "error"); - const hint = new ErrorHint(hintPair.hint, "hint"); - error.addChild(hint); - this.data.push(error); - - if (!hintPair.hint.startsWith("No hints found for")) { - meaningfulHintFound = true; - } - } + // Process OpenOCD hints + if (openOcdHintsPath && (await pathExists(openOcdHintsPath))) { + try { + const fileContents = await readFile(openOcdHintsPath, "utf-8"); + const hintsData = yaml.load(fileContents); + const reHintsPairArray: ReHintPair[] = this.loadOpenOcdHints( + hintsData + ); + + meaningfulHintFound = + (await this.processHints(errorMsg, reHintsPairArray)) || + meaningfulHintFound; + } catch (error) { + Logger.errorNotify( + `Error processing OpenOCD hints file (line ${error.mark?.line}): ${error.message}`, + error, + "ErrorHintProvider searchError" + ); } + } else if (openOcdHintsPath) { + Logger.info(`${openOcdHintsPath} does not exist.`); } - if (!this.data.length) { - this.data.push( - new ErrorHint(`No hints found for ${errorMsg}`, "error") + if (this.buildErrorData.length === 0) { + this.buildErrorData.push( + new ErrorHintTreeItem(`No hints found for ${errorMsg}`, "error") ); } @@ -143,7 +247,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { return meaningfulHintFound; } catch (error) { Logger.errorNotify( - `Error processing hints file (line ${error.mark?.line}): ${error.message}`, + `Error processing hints file: ${error.message}`, error, "ErrorHintProvider searchError" ); @@ -151,10 +255,194 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { } } - private loadHints(hintsArray: any): ReHintPair[] { + // Process hints + private async processHints( + errorMsg: string, + reHintsPairArray: ReHintPair[] + ): Promise { + let meaningfulHintFound = false; + let errorFullMessage = ""; + + for (const hintPair of reHintsPairArray) { + const match = new RegExp(hintPair.re, "i").exec(errorMsg); + const regexParts = []; + // Extract meaningful parts from regex by breaking at top-level pipes + // outside of parentheses or use a proper regex parser + const mainPattern = hintPair.re.replace(/^.*?'(.*)'.*$/, '$1'); // Extract pattern between quotes if present + if (mainPattern) { + // Split by top-level pipes, preserving grouped expressions + const parts = mainPattern.split(/\|(?![^(]*\))/); + for (const part of parts) { + // Clean up any remaining parentheses for direct string matching + const cleaned = part.replace(/[()]/g, ''); + if (cleaned.length > 3) { // Avoid very short fragments + regexParts.push(cleaned.toLowerCase()); + } + } + } + if ( + match || hintPair.re.toLowerCase().includes(errorMsg) || + regexParts.some((part) => errorMsg.toLowerCase().includes(part)) + ) { + let finalHint = hintPair.hint; + + if (match && hintPair.match_to_output && hintPair.hint.includes("{}")) { + finalHint = hintPair.hint.replace("{}", match[0]); + } else if (!match && hintPair.hint.includes("{}")) { + const matchedSubstring = regexParts.find((part) => + errorMsg.toLowerCase().includes(part.toLowerCase()) + ); + finalHint = hintPair.hint.replace("{}", matchedSubstring || ""); // Handle case where nothing is matched + } + + // Create hint children + const hintChildren: ErrorHintTreeItem[] = []; + + // Add reference as child if available + if (hintPair.ref) { + hintChildren.push(new ErrorHintTreeItem(hintPair.ref, "reference")); + } + + // Create hint with children + const hint = new ErrorHintTreeItem(finalHint, "hint", hintChildren, hintPair.ref); + + // Create error with hint as child + // Display matched error message + errorFullMessage = hintPair.re; + const error = new ErrorHintTreeItem(errorFullMessage, "error", [hint]); + + // Add to build error data + this.buildErrorData.push(error); + + if (!finalHint.startsWith("No hints found for")) { + meaningfulHintFound = true; + } + } + } + + // If no direct matches, try partial matches + if (this.buildErrorData.length === 0) { + for (const hintPair of reHintsPairArray) { + if (hintPair.re.toLowerCase().includes(errorMsg.toLowerCase())) { + // Create hint children + const hintChildren: ErrorHintTreeItem[] = []; + + // Add reference as child if available + if (hintPair.ref) { + hintChildren.push(new ErrorHintTreeItem(hintPair.ref, "reference")); + } + + // Create hint with children + const hint = new ErrorHintTreeItem(hintPair.hint, "hint", hintChildren, hintPair.ref); + + // Create error with hint as child + const error = new ErrorHintTreeItem(hintPair.re, "error", [hint]); + + // Add to build error data + this.buildErrorData.push(error); + + if (!hintPair.hint.startsWith("No hints found for")) { + meaningfulHintFound = true; + } + } + } + } + + return meaningfulHintFound; + } + + // Get hint for an error message + public getHintForError( + errorMsg: string + ): { hint?: string; ref?: string } | undefined { + + // Check in build errors + for (const errorHint of this.buildErrorData) { + if (errorHint.label.toLowerCase().includes(errorMsg.toLowerCase()) && errorHint.children.length > 0) { + const hintItem = errorHint.children[0]; + return { + hint: hintItem.label.replace(/^💡 /, ''), + ref: hintItem.reference + }; + } + } + + // No match found + return undefined; + } + + /** + * Loads hints from the parsed YAML array and converts them to ReHintPair objects + * + * @param hintsArray - Array of hint definitions from YAML + * @returns Array of ReHintPair objects ready for matching against error messages + * + * Example input: + * [ + * { + * re: "fatal error: (spiram.h|esp_spiram.h): No such file or directory", + * hint: "{} was removed. Include esp_psram.h instead.", + * match_to_output: true + * }, + * { + * re: "error: implicit declaration of function '{}'", + * hint: "Function '{}' has been removed. Please use {}.", + * variables: [ + * { + * re_variables: ["esp_random"], + * hint_variables: ["esp_random()", "esp_fill_random()"] + * } + * ] + * } + * ] + */ + loadHints(hintsArray: any[]): ReHintPair[] { + let reHintsPairArray: ReHintPair[] = []; + + for (const entry of hintsArray) { + // Case 1: Entry has variables + if (entry.variables && entry.variables.length) { + // Handle variable-based entries + for (const variableSet of entry.variables) { + const reVariables = variableSet.re_variables || []; + const hintVariables = variableSet.hint_variables || []; + + let re = this.formatEntry(reVariables, entry.re); + let hint = this.formatEntry(hintVariables, entry.hint); + + reHintsPairArray.push( + new ReHintPair(re, hint, entry.match_to_output) + ); + } + } else { + // Case 2: Simple entry without variables + let re = String(entry.re); + let hint = String(entry.hint); + + if (!entry.match_to_output) { + // Simple case: no need to insert matched content into hint + re = this.formatEntry([], re); + hint = this.formatEntry([], hint); + reHintsPairArray.push(new ReHintPair(re, hint, false)); + } else { + // Complex case: need to expand alternatives and insert matches + // E.g., "(spiram.h|esp_spiram.h)" should create two separate entries + const reHintPairs = this.expandAlternatives(re, hint); + for (const pair of reHintPairs) { + reHintsPairArray.push(new ReHintPair(pair.re, pair.hint, true)); + } + } + } + } + + return reHintsPairArray; + } + + private loadOpenOcdHints(hintsArray: any): ReHintPair[] { let reHintsPairArray: ReHintPair[] = []; for (const entry of hintsArray) { + // Ignore all properties that are not "re", "hint", "match_to_output", "variables" or "ref" if (entry.variables && entry.variables.length) { for (const variableSet of entry.variables) { const reVariables = variableSet.re_variables; @@ -164,7 +452,7 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { let hint = this.formatEntry(hintVariables, entry.hint); reHintsPairArray.push( - new ReHintPair(re, hint, entry.match_to_output) + new ReHintPair(re, hint, entry.match_to_output, entry.ref) ); } } else { @@ -176,59 +464,113 @@ export class ErrorHintProvider implements vscode.TreeDataProvider { hint = this.formatEntry([], hint); } - reHintsPairArray.push(new ReHintPair(re, hint, entry.match_to_output)); + reHintsPairArray.push( + new ReHintPair(re, hint, entry.match_to_output, entry.ref) + ); } } return reHintsPairArray; } + /** + * Formats an entry string by replacing {} placeholders with values from vars array + * + * @param vars - Array of values to insert into placeholders + * @param entry - Template string with {} placeholders + * @returns Formatted string with placeholders replaced by values + * + * Example: + * formatEntry(["esp_random", "esp_fill_random"], "Function '{}' has been renamed to '{}'.") + * Result: "Function 'esp_random' has been renamed to 'esp_fill_random'." + */ private formatEntry(vars: string[], entry: string): string { let i = 0; - while (entry.includes("{}")) { - entry = entry.replace("{}", "{" + i++ + "}"); + let formattedEntry = entry; + + // Replace {} with indexed placeholders {0}, {1}, etc. + while (formattedEntry.includes("{}")) { + formattedEntry = formattedEntry.replace("{}", "{" + i++ + "}"); } - const result = entry.replace( + + // Replace indexed placeholders with values from vars array + const result = formattedEntry.replace( /\{(\d+)\}/g, (_, idx) => vars[Number(idx)] || "" ); + return result; } - getTreeItem(element: ErrorHint): vscode.TreeItem { - let treeItem = new vscode.TreeItem(element.label); - - if (element.type === "error") { - if (element.label.startsWith("No hints found")) { - treeItem.label = `⚠️ ${element.label}`; + /** + * Expands regex patterns with alternatives into separate entries + * This is critical for match_to_output: true cases where the match needs + * to be inserted into the hint + * + * @param re - Regular expression string with possible alternatives in parentheses + * @param hint - Hint template with {} placeholders for matches + * @returns Array of {re, hint} pairs with alternatives expanded + * + * Example: + * expandAlternatives( + * "fatal error: (spiram.h|esp_spiram.h): No such file or directory", + * "{} was removed. Include esp_psram.h instead." + * ) + * + * Results in: + * [ + * { + * re: "fatal error: spiram.h: No such file or directory", + * hint: "spiram.h was removed. Include esp_psram.h instead." + * }, + * { + * re: "fatal error: esp_spiram.h: No such file or directory", + * hint: "esp_spiram.h was removed. Include esp_psram.h instead." + * } + * ] + */ + private expandAlternatives(re: string, hint: string): Array<{re: string, hint: string}> { + const result: Array<{re: string, hint: string}> = []; + + // Find all alternatives in parentheses with pipe characters + // Example: in "(spiram.h|esp_spiram.h)" we'll find alternatives "spiram.h" and "esp_spiram.h" + const alternativeMatches = re.match(/\(([^()]*\|[^()]*)\)/g); + + if (!alternativeMatches) { + // No alternatives found, return the original as-is + return [{re, hint}]; + } + + // Process each alternative group + for (const match of alternativeMatches) { + const alternatives = match.slice(1, -1).split('|'); // Remove parens and split by pipe + + if (result.length === 0) { + // Initial population of result + for (const alt of alternatives) { + const newRe = re.replace(match, alt); + // For each alternative, create a new hint with the alternative inserted + const newHint = hint.replace(/\{\}/, alt); + result.push({re: newRe, hint: newHint}); + } } else { - treeItem.label = `🔍 ${element.label}`; - treeItem.collapsibleState = vscode.TreeItemCollapsibleState.Expanded; // Ensure errors are expanded by default + // For subsequent alternative groups, multiply the existing results + const currentResults = [...result]; + result.length = 0; + + for (const existingEntry of currentResults) { + for (const alt of alternatives) { + const newRe = existingEntry.re.replace(match, alt); + // For each alternative, create a new hint with the alternative inserted + const newHint = existingEntry.hint.replace(/\{\}/, alt); + result.push({re: newRe, hint: newHint}); + } + } } - } else if (element.type === "hint") { - treeItem.label = `💡 ${element.label}`; - } - - return treeItem; - } - - getChildren(element?: ErrorHint): Thenable { - if (element) { - return Promise.resolve(element.children); // Return children if there's a parent element - } else { - return Promise.resolve(this.data); } + + return result; } - - clearErrorHints() { - this.data = []; - this._onDidChangeTreeData.fire(); // Notify the view to refresh - } -} - -function getHintsYmlPath(espIdfPath: string): string { - const separator = os.platform() === "win32" ? "\\" : "/"; - return `${espIdfPath}${separator}tools${separator}idf_py_actions${separator}hints.yml`; } export class HintHoverProvider implements vscode.HoverProvider { @@ -239,25 +581,99 @@ export class HintHoverProvider implements vscode.HoverProvider { position: vscode.Position, token: vscode.CancellationToken ): vscode.ProviderResult { - const diagnostics = vscode.languages.getDiagnostics(document.uri); + // Get all diagnostics for this document + const diagnostics = vscode.languages + .getDiagnostics(document.uri) + .filter( + (diagnostic) => + diagnostic.source === "esp-idf" && + diagnostic.severity === vscode.DiagnosticSeverity.Error + ); + // No ESP-IDF diagnostics found for this document + if (!diagnostics.length) { + return null; + } + + // Find diagnostics that contain the hover position for (const diagnostic of diagnostics) { - const start = diagnostic.range.start; - const end = diagnostic.range.end; + // Check if position is within the diagnostic range + // We'll be slightly more generous with the range to make it easier to hover + const range = diagnostic.range; + + // Expand the range slightly to make it easier to hover + const lineText = document.lineAt(range.start.line).text; + const expandedRange = new vscode.Range( + new vscode.Position(range.start.line, 0), + new vscode.Position(range.end.line, lineText.length) + ); - // Check if the position is within or immediately adjacent to the diagnostic range - if ( - diagnostic.severity === vscode.DiagnosticSeverity.Error && - position.line === start.line && - position.character >= start.character - 1 && - position.character <= end.character + 1 - ) { - const hint = this.hintProvider.getHintForError(diagnostic.message); - if (hint) { - return new vscode.Hover(`ESP-IDF Hint: ${hint}`); + // Check if position is within the expanded range + if (expandedRange.contains(position)) { + // Get hint object for this error message + const hintInfo = this.hintProvider.getHintForError(diagnostic.message); + + if (hintInfo && hintInfo.hint) { + let hoverMessage = `**ESP-IDF Hint**: ${hintInfo.hint}`; + + // Add reference link if available + if (hintInfo.ref) { + hoverMessage += `\n\n[Reference Documentation](${hintInfo.ref})`; + } + // We found a hint, return it with markdown formatting + return new vscode.Hover(new vscode.MarkdownString(`${hoverMessage}`)); } } } + + // No matching diagnostics found at this position + return null; + } +} + +function getIdfHintsYmlPath(espIdfPath: string): string { + return path.join(espIdfPath, "tools", "idf_py_actions", "hints.yml"); +} + +async function getOpenOcdHintsYmlPath( + workspace: vscode.Uri +): Promise { + try { + const idfToolsPath = idfConf.readParameter( + "idf.toolsPath", + workspace + ) as string; + + const openOCDManager = OpenOCDManager.init(); + const version = await openOCDManager.version(); + + if (!version) { + Logger.infoNotify( + "Could not determine OpenOCD version. Hints file won't be loaded." + ); + return null; + } + + const hintsPath = path.join( + idfToolsPath, + "tools", + "openocd-esp32", + version, + "openocd-esp32", + "share", + "openocd", + "espressif", + "tools", + "esp_problems_hints.yml" + ); + + return hintsPath; + } catch (error) { + Logger.errorNotify( + `Error getting OpenOCD hints path: ${error.message}`, + error, + "getOpenOcdHintsYmlPath" + ); return null; } } diff --git a/src/espIdf/hints/openocdhint.ts b/src/espIdf/hints/openocdhint.ts new file mode 100644 index 000000000..d58c9b358 --- /dev/null +++ b/src/espIdf/hints/openocdhint.ts @@ -0,0 +1,332 @@ +// Copyright 2025 Espressif Systems (Shanghai) CO LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +import * as vscode from "vscode"; +import * as yaml from "js-yaml"; +import { readFile, pathExists } from "fs-extra"; +import * as path from "path"; +import * as idfConf from "../../idfConfiguration"; +import { Logger } from "../../logger/logger"; +import { PreCheck } from "../../utils"; +import { OpenOCDManager } from "../openOcd/openOcdManager"; +import { ErrorHintProvider } from "./index"; + +interface OpenOCDHint { + source?: string; + re: string; + hint: string; + ref?: string; + match_to_output?: boolean; + variables?: Array<{ + re_variables: string[]; + hint_variables: string[]; + }>; +} + +export class OpenOCDErrorMonitor { + private static instance: OpenOCDErrorMonitor; + private errorHintProvider: ErrorHintProvider; + private hintsData: OpenOCDHint[] = []; + private errorBuffer: string[] = []; + private workspaceRoot: vscode.Uri; + private debounceTimer: NodeJS.Timeout | null = null; + private openOCDLogWatcher: vscode.Disposable | null = null; + private readonly DEBOUNCE_TIME = 300; // ms + + private constructor( + errorHintProvider: ErrorHintProvider, + workspaceRoot: vscode.Uri + ) { + this.errorHintProvider = errorHintProvider; + this.workspaceRoot = workspaceRoot; + } + + public static init( + errorHintProvider: ErrorHintProvider, + workspaceRoot: vscode.Uri + ): OpenOCDErrorMonitor { + if (!OpenOCDErrorMonitor.instance) { + OpenOCDErrorMonitor.instance = new OpenOCDErrorMonitor( + errorHintProvider, + workspaceRoot + ); + } + return OpenOCDErrorMonitor.instance; + } + + public async initialize(): Promise { + try { + // Check OpenOCD version first + const openOCDManager = OpenOCDManager.init(); + const version = await openOCDManager.version(); + + if (!version) { + Logger.info( + "Could not determine OpenOCD version. Hints file won't be loaded." + ); + return null; + } + + // Skip initialization if openOCD version is not supporting hints + const minRequiredVersion = "v0.12.0-esp32-20250226"; + if (!version || !PreCheck.openOCDVersionValidator(minRequiredVersion, version)) { + Logger.info(`OpenOCD version ${version} doesn't support hints. Minimum required: ${minRequiredVersion}`); + return; + } + + // Load OpenOCD hints data + const toolsPath = idfConf.readParameter( + "idf.toolsPath", + this.workspaceRoot + ) as string; + + const openOcdHintsPath = await this.getOpenOcdHintsYmlPath(toolsPath, version); + + if (openOcdHintsPath && (await pathExists(openOcdHintsPath))) { + try { + const fileContents = await readFile(openOcdHintsPath, "utf-8"); + this.hintsData = yaml.load(fileContents) as OpenOCDHint[]; + Logger.info(`Loaded OpenOCD hints from ${openOcdHintsPath}`); + } catch (error) { + Logger.errorNotify( + `Error processing OpenOCD hints file: ${error.message}`, + error, + "OpenOCDErrorMonitor initialize" + ); + } + } else { + Logger.info(`OpenOCD hints file not found at ${openOcdHintsPath}`); + } + + // Start monitoring OpenOCD output + this.watchOpenOCDStatus(); + } catch (error) { + Logger.errorNotify( + `Error initializing OpenOCD error monitor: ${error.message}`, + error, + "OpenOCDErrorMonitor initialize" + ); + } + } + + public dispose(): void { + if (this.openOCDLogWatcher) { + this.openOCDLogWatcher.dispose(); + this.openOCDLogWatcher = null; + } + + if (this.debounceTimer) { + clearTimeout(this.debounceTimer); + this.debounceTimer = null; + } + } + + private async getOpenOcdHintsYmlPath(toolsPath: string, version: string): Promise { + try { + + const hintsPath = path.join( + toolsPath, + "tools", + "openocd-esp32", + version, + "openocd-esp32", + "share", + "openocd", + "espressif", + "tools", + "esp_problems_hints.yml" + ); + + return hintsPath; + } catch (error) { + Logger.errorNotify( + `Error getting OpenOCD hints path: ${error.message}`, + error, + "getOpenOcdHintsYmlPath" + ); + return null; + } + } + + private watchOpenOCDStatus(): void { + // Set up watcher for OpenOCD output + if (this.openOCDLogWatcher) { + this.openOCDLogWatcher.dispose(); + } + + const openOCDManager = OpenOCDManager.init(); + + // Add event listener to OpenOCDManager to detect when there's new output + openOCDManager.on("data", (data) => { + const content = data.toString(); + this.processOutput(content); + }); + + openOCDManager.on("error", (error, data) => { + const content = data ? data.toString() : error.message; + this.processOutput(content); + }); + + this.openOCDLogWatcher = { + dispose: () => { + openOCDManager.removeAllListeners("data"); + openOCDManager.removeAllListeners("error"); + } + }; + } + + private processOutput(content: string): void { + if (!content) return; + + // Split into lines and process each line + const lines = content.split('\n'); + + for (const line of lines) { + this.processOutputLine(line.trim()); + } + } + + public processOutputLine(line: string): void { + // Skip empty lines + if (!line) return; + + // Add line to buffer + this.errorBuffer.push(line); + + // Keep the buffer at a reasonable size (last 100 lines) + if (this.errorBuffer.length > 100) { + this.errorBuffer.shift(); + } + + // Check for OpenOCD error patterns in the recent output + if (line.includes("Error:") || line.includes("Warn:")) { + this.debouncedAnalyzeErrors(); + } + } + + private debouncedAnalyzeErrors(): void { + // Debounce to avoid excessive processing + if (this.debounceTimer) { + clearTimeout(this.debounceTimer); + } + + this.debounceTimer = setTimeout(() => { + this.analyzeErrors(); + }, this.DEBOUNCE_TIME); + } + + private async analyzeErrors(): Promise { + try { + // Get the last few lines of context that might contain errors + const context = this.errorBuffer.join("\n"); + + // Look for error patterns + for (const hint of this.hintsData) { + // Skip if the hint is for a specific source that doesn't match + if (hint.source && hint.source !== 'ocd') { + continue; + } + + // Process variables if they exist + if (hint.variables && hint.variables.length > 0) { + let foundMatch = false; + + for (const variableSet of hint.variables) { + const reVariables = variableSet.re_variables; + const hintVariables = variableSet.hint_variables; + + let re = this.formatEntry(reVariables, hint.re); + let hintMsg = this.formatEntry(hintVariables, hint.hint); + + const regex = new RegExp(re, 'i'); + const match = regex.exec(context); + + if (match) { + // Format the hint message if match_to_output is true + if (hint.match_to_output && match.length > 0 && hintMsg.includes("{}")) { + hintMsg = hintMsg.replace("{}", match[0]); + } + + // Show the error hint + await this.showErrorHint(match[0], hintMsg, hint.ref); + foundMatch = true; + break; + } + } + + if (foundMatch) break; + } else { + // No variables, just check the regex directly + const regex = new RegExp(hint.re, 'i'); + const match = regex.exec(context); + + if (match) { + // Format the hint message + let hintMessage = hint.hint; + + if (hint.match_to_output && match.length > 0 && hintMessage.includes("{}")) { + hintMessage = hintMessage.replace("{}", match[0]); + } + + // Trigger the error hint display + await this.showErrorHint(match[0], hintMessage, hint.ref); + + // Only show one hint at a time to avoid overwhelming the user + break; + } + } + } + } catch (error) { + Logger.errorNotify( + `Error analyzing OpenOCD output: ${error.message}`, + error, + "analyzeErrors" + ); + } + } + + private formatEntry(vars: string[], entry: string): string { + let formattedEntry = entry; + + // Replace numbered placeholders with variables + let i = 0; + while (formattedEntry.includes("{}")) { + formattedEntry = formattedEntry.replace("{}", `{${i++}}`); + } + + // Replace {n} with corresponding variable from vars array + formattedEntry = formattedEntry.replace(/\{(\d+)\}/g, (match, idx) => { + const index = parseInt(idx, 10); + return index < vars.length ? vars[index] : ""; + }); + + return formattedEntry; + } + + private async showErrorHint(errorMessage: string, hintMessage: string, reference?: string): Promise { + try { + // Use the existing error hint provider to display the hint + await this.errorHintProvider.showOpenOCDErrorHint(errorMessage, hintMessage, reference); + + // Focus the error hints view + await vscode.commands.executeCommand("idfErrorHints.focus"); + } catch (error) { + Logger.errorNotify( + `Error showing OpenOCD error hint: ${error.message}`, + error, + "showErrorHint" + ); + } + } +} \ No newline at end of file diff --git a/src/extension.ts b/src/extension.ts index 67790a829..67596f8e1 100644 --- a/src/extension.ts +++ b/src/extension.ts @@ -41,7 +41,10 @@ import { ExamplesPlanel } from "./examples/ExamplesPanel"; import * as idfConf from "./idfConfiguration"; import { Logger } from "./logger/logger"; import { OutputChannel } from "./logger/outputChannel"; -import { showInfoNotificationWithAction } from "./logger/utils"; +import { + showInfoNotificationWithAction, + showInfoNotificationWithMultipleActions, +} from "./logger/utils"; import * as utils from "./utils"; import { PreCheck } from "./utils"; import { @@ -158,7 +161,11 @@ import { checkDebugAdapterRequirements } from "./espIdf/debugAdapter/checkPyReqs import { CDTDebugConfigurationProvider } from "./cdtDebugAdapter/debugConfProvider"; import { CDTDebugAdapterDescriptorFactory } from "./cdtDebugAdapter/server"; import { IdfReconfigureTask } from "./espIdf/reconfigure/task"; -import { ErrorHintProvider, HintHoverProvider } from "./espIdf/hints/index"; +import { + ErrorHintProvider, + ErrorHintTreeItem, + HintHoverProvider, +} from "./espIdf/hints/index"; import { installWebsocketClient } from "./espIdf/monitor/checkWebsocketClient"; import { TroubleshootingPanel } from "./support/troubleshootPanel"; import { @@ -173,6 +180,7 @@ import { } from "./cmdTreeView/cmdStore"; import { IdfSetup } from "./views/setup/types"; import { asyncRemoveEspIdfSettings } from "./uninstall"; +import { OpenOCDErrorMonitor } from "./espIdf/hints/openocdhint"; // Global variables shared by commands let workspaceRoot: vscode.Uri; @@ -275,6 +283,9 @@ export async function activate(context: vscode.ExtensionContext) { vscode.commands.registerCommand(name, telemetryCallback) ); }; + // Store display hints notification (until VS Code is closed) + context.workspaceState.update("idf.showHintsNotification", true); + // init rainmaker cache store ESP.Rainmaker.store = RainmakerStore.init(context); @@ -3683,55 +3694,129 @@ export async function activate(context: vscode.ExtensionContext) { "espressif.esp-idf-extension#espIdf.walkthrough.basic-usage" ); } - // Hints Viewer - const treeDataProvider = new ErrorHintProvider(context); - vscode.window.registerTreeDataProvider("errorHints", treeDataProvider); + // Create and register the tree view with collapse all button + const treeView = vscode.window.createTreeView("idfErrorHints", { + treeDataProvider: treeDataProvider, + showCollapseAll: true, + }); + + // Set a title for the tree view + treeView.title = "Error Hints"; + + // Add the tree view to disposables + context.subscriptions.push(treeView); + + // Register commands for clearing error hints + vscode.commands.registerCommand("espIdf.errorHints.clearAll", () => { + treeDataProvider.clearErrorHints(true); // Clear both build and OpenOCD errors + }); + + vscode.commands.registerCommand("espIdf.errorHints.clearBuildErrors", () => { + treeDataProvider.clearErrorHints(false); // Clear only build errors + }); + + vscode.commands.registerCommand( + "espIdf.errorHints.clearOpenOCDErrors", + () => { + treeDataProvider.clearOpenOCDErrorsOnly(); // Clear only OpenOCD errors + } + ); + + // Initialize OpenOCD error monitoring + const openOCDErrorMonitor = OpenOCDErrorMonitor.init( + treeDataProvider, + workspaceRoot + ); + await openOCDErrorMonitor.initialize(); + + // Register disposal of the monitor + context.subscriptions.push({ + dispose: () => { + openOCDErrorMonitor.dispose(); + }, + }); + + // Register command to manually search for errors vscode.commands.registerCommand("espIdf.searchError", async () => { const errorMsg = await vscode.window.showInputBox({ placeHolder: "Enter the error message", }); if (errorMsg) { treeDataProvider.searchError(errorMsg, workspaceRoot); - await vscode.commands.executeCommand("errorHints.focus"); + await vscode.commands.executeCommand("idfErrorHints.focus"); } }); - // Function to process diagnostics and update error hints - const processDiagnostics = async (uri: vscode.Uri) => { - const diagnostics = vscode.languages.getDiagnostics(uri); + // Function to process all ESP-IDF diagnostics from the problems panel + const processEspIdfDiagnostics = async () => { + // Get all diagnostics from all files that have source "esp-idf" + const espIdfDiagnostics: Array<{ + uri: vscode.Uri; + diagnostic: vscode.Diagnostic; + }> = []; + + // Collect all diagnostics from all files that have source "esp-idf" + vscode.languages.getDiagnostics().forEach(([uri, diagnostics]) => { + diagnostics + .filter( + (d) => + d.source === "esp-idf" && + d.severity === vscode.DiagnosticSeverity.Error + ) + .forEach((diagnostic) => { + espIdfDiagnostics.push({ uri, diagnostic }); + }); + }); - const errorDiagnostics = diagnostics.filter( - (d) => d.severity === vscode.DiagnosticSeverity.Error + // Only clear build errors if no ESP-IDF diagnostics + if (espIdfDiagnostics.length === 0) { + treeDataProvider.clearErrorHints(false); // Don't clear OpenOCD errors + return; + } + + // Process the first error if available + const errorMsg = espIdfDiagnostics[0].diagnostic.message; + const foundHint = await treeDataProvider.searchError( + errorMsg, + workspaceRoot ); - if (errorDiagnostics.length > 0) { - const errorMsg = errorDiagnostics[0].message; - await treeDataProvider.searchError(errorMsg, workspaceRoot); - } else { - treeDataProvider.clearErrorHints(); + const showHintsNotification = context.workspaceState.get( + "idf.showHintsNotification" + ); + if (foundHint && showHintsNotification) { + const actions = [ + { + label: vscode.l10n.t("💡 Show Hints"), + action: () => vscode.commands.executeCommand("idfErrorHints.focus"), + }, + { + label: vscode.l10n.t("Mute for this session"), + action: () => { + context.workspaceState.update("idf.showHintsNotification", false); + vscode.window.showInformationMessage( + vscode.l10n.t( + "Hint notifications muted for this session. You can still access hints manually in ESP-IDF bottom panel" + ) + ); + }, + }, + ]; + + await showInfoNotificationWithMultipleActions( + vscode.l10n.t(`Possible hint found for the error: {0}`, errorMsg), + actions + ); } }; // Attach a listener to the diagnostics collection - context.subscriptions.push( - vscode.languages.onDidChangeDiagnostics((event) => { - event.uris.forEach((uri) => { - processDiagnostics(uri); - }); - }) - ); - - // Listen to the active text editor change event - context.subscriptions.push( - vscode.window.onDidChangeActiveTextEditor((editor) => { - if (editor) { - processDiagnostics(editor.document.uri); - } - }) - ); + vscode.languages.onDidChangeDiagnostics((_event) => { + processEspIdfDiagnostics(); + }); // Register the HintHoverProvider context.subscriptions.push( diff --git a/src/logger/utils.ts b/src/logger/utils.ts index 2d4576381..216520cde 100644 --- a/src/logger/utils.ts +++ b/src/logger/utils.ts @@ -23,6 +23,39 @@ export async function showInfoNotificationWithAction( } } +/** + * Shows an information notification with multiple buttons that execute custom actions when clicked. + * @param {string} infoMessage - The information message to display. + * @param {Array<{label: string, action: NotificationAction}>} actions - An array of objects, each containing a button label and an action to perform when clicked. + * @returns {Promise} - A promise that resolves when the notification is shown and handled. + * @example + * showInfoNotificationWithMultipleActions( + * "Solution available", + * [ + * { label: "View Solution", action: () => openSolution() }, + * { label: "Mute for this session", action: () => disableNotifications() } + * ] + * ); + */ +export async function showInfoNotificationWithMultipleActions( + infoMessage: string, + actions: { label: string; action: NotificationAction }[] +): Promise { + const selectedOption = await vscode.window.showInformationMessage( + infoMessage, + ...actions.map((action) => action.label) + ); + + if (selectedOption) { + const selectedAction = actions.find( + (action) => action.label === selectedOption + ); + if (selectedAction) { + await Promise.resolve(selectedAction.action()); + } + } +} + /** * Shows an error notification with a button that opens a link when clicked. * @param {string} infoMessage - The waning message to display.