Add "Open Merge View" link in Problems view

Author: mguzmanm

src/desktop/extension.ts

@@ -59,6 +59,7 @@ import { EditCommand } from '../views/solution-outline/commands/edit-command';
 import { OpenCommand } from '../views/solution-outline/commands/open-command';
 import { FindCommand } from '../views/solution-outline/commands/find-command';
 import { MergeCommand } from '../views/solution-outline/commands/merge-command';
+import { MergeNodeResolverImpl } from '../views/solution-outline/merge-node-resolver';
 import { SolutionOutlineView } from '../views/solution-outline/solution-outline';
 import { TreeViewFileDecorationProvider } from '../views/solution-outline/treeview-decoration-provider';
 import { TreeViewProviderImpl } from '../views/solution-outline/treeview-provider';
@@ -217,8 +218,11 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
     const copyHeaderCommand = new CopyHeaderCommand(commandsProvider);
     const openCommand = new OpenCommand(solutionManager, commandsProvider, externalFileOpener);
     const findCommand = new FindCommand(commandsProvider);
-    const mergeCommand = new MergeCommand(commandsProvider, activeSolutionTracker);
     const fileDecorationProviderManager = new FileDecorationProviderManagerImpl();
+    const treeViewProviderImpl = new TreeViewProviderImpl(SolutionOutlineView.treeViewId);
+    const treeViewFileDecorationProvider = new TreeViewFileDecorationProvider(fileDecorationProviderManager, themeProvider);
+    const mergeNodeResolver = new MergeNodeResolverImpl();
+    const mergeCommand = new MergeCommand(commandsProvider, activeSolutionTracker, mergeNodeResolver);
     const buildCommand = new BuildCommand(buildTaskProvider, commandsProvider, buildTaskDefinitionBuilder);
     const runGeneratorCommand = new GeneratorCommand(commandsProvider, solutionManager, outputChannelProvider, cmsisToolboxManager);
     const armclangDefineGetter = new ArmclangDefineGetter(processManager, workspaceFsProvider);
@@ -245,10 +249,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
     const targetPackCommand = new TargetPackCommandImpl(commandsProvider, solutionManager);
     const debugHardwareCommands = new DebugHardwareCommands(commandsProvider, solutionManager);
     const csolutionExtension = new CsolutionExtensionImpl(solutionCreator, buildTaskProvider, dataManager);
-    const treeViewProviderImpl = new TreeViewProviderImpl(SolutionOutlineView.treeViewId);
-
-    const treeViewFileDecorationProvider = new TreeViewFileDecorationProvider(fileDecorationProviderManager, themeProvider);
-    const solutionOutline = new SolutionOutlineView(solutionManager, treeViewProviderImpl, globalStateProvider, treeViewFileDecorationProvider);
+    const solutionOutline = new SolutionOutlineView(solutionManager, treeViewProviderImpl, globalStateProvider, treeViewFileDecorationProvider, mergeNodeResolver);
     const cmsisCommands = new CmsisCommands(configurationProvider, commandsProvider, solutionManager, debugProvider, serialMonitorExtension);
     const buildStopCommand = new BuildStopCommand(commandsProvider, buildTaskProvider);
     const configurationWizardView = new ConfWizWebview(context);

src/solutions/solution-problems.test.ts

@@ -23,6 +23,7 @@ import { solutionManagerFactory, MockSolutionManager } from './solution-manager.
 import { SolutionEventHub } from './solution-event-hub';
 import { enrichLogMessagesFromToolOutput, SolutionProblemsImpl } from './solution-problems';
 import { waitTimeout } from '../__test__/test-waits';
+import { createMergeCommandUri, MERGE_VIEW_LINK_LABEL } from '../views/solution-outline/commands/merge-message-parser';
 
 const solutionPath = '/work/app.csolution.yml';
 const layerPath = '/work/config/mylayer.clayer.yml';
@@ -173,4 +174,36 @@ describe('SolutionProblems', () => {
         expect(messages.errors[0]).toContain('.vscode');
         expect(messages.errors[0]).toContain('settings.json:3:5 - exec: "west": executable file not found in $PATH; review "cmsis-csolution.environmentVariables"');
     });
+
+    it('creates Open Merge View code action for merge advisory diagnostics', async () => {
+        await solutionProblems.activate({ subscriptions: [] } as unknown as ExtensionContext);
+        const setSpy = jest.spyOn(vscode.languages.createDiagnosticCollection(), 'set');
+        const localPath = 'C:/Users/myuser/my_csolution_examples/CubeMX/CubeMX/RTE/CMSIS/RTX_Config.c';
+
+        await eventHub.fireConvertCompleted({
+            severity: 'warning',
+            detection: false,
+            logMessages: {
+                success: true,
+                errors: [],
+                warnings: [
+                    `file '${localPath}' update recommended; merge content from update file, rename update file to base file and remove previous base file`,
+                ],
+                info: [],
+            },
+        });
+        await waitTimeout();
+
+        const setCalls = setSpy.mock.calls as unknown as Array<[vscode.Uri, readonly vscode.Diagnostic[] | undefined]>;
+        const diagnostics = setCalls.flatMap(([, entries]) => [...(entries ?? [])]);
+        const mergeDiagnostic = diagnostics.find(d => d.code !== undefined);
+
+        expect(mergeDiagnostic).toBeDefined();
+        expect(mergeDiagnostic!.message).toBe('RTX_Config.c has a new version available for merge.');
+        expect(mergeDiagnostic!.source).toBe('csolution');
+        expect(mergeDiagnostic!.code).toEqual({
+            value: MERGE_VIEW_LINK_LABEL,
+            target: vscode.Uri.parse(createMergeCommandUri(localPath)),
+        });
+    });
 });

src/solutions/solution-problems.ts

@@ -22,6 +22,7 @@ import * as fsUtils from '../utils/fs-utils';
 import { getFileNameFromPath } from '../utils/path-utils';
 import { stripTwoExtensions } from '../utils/string-utils';
 import { getWorkspaceFolder } from '../utils/vscode-utils';
+import { createMergeCommandUri, createMergeDiagnosticMessage, MERGE_VIEW_LINK_LABEL, parseMergeMessage } from '../views/solution-outline/commands/merge-message-parser';
 import { SolutionManager } from './solution-manager';
 import { ConvertResultData, SolutionEventHub } from './solution-event-hub';
 
@@ -144,7 +145,7 @@ export class SolutionProblemsImpl implements SolutionProblems {
         // parse message according to logMessageRegex
         const m = message.match(this.logMessageRegex);
         if (m?.groups) {
-            const { filename, line, column, message } = m.groups;
+            const { filename, line, column, message: diagnosticMessage } = m.groups;
             const normalizedFilename = filename ? getFileNameFromPath(filename) : undefined;
             const fromMap = (filename && files.get(filename)) || (normalizedFilename && files.get(normalizedFilename));
             const file = fromMap || (filename && path.isAbsolute(filename) ? filename : undefined) || this.solutionManager.getCsolution()?.solutionPath;
@@ -164,18 +165,31 @@ export class SolutionProblemsImpl implements SolutionProblems {
                     // Keep default endCharacter when document cannot be opened.
                 }
             }
+            const merge = parseMergeMessage(diagnosticMessage);
+            const normalizedMessage = merge
+                ? createMergeDiagnosticMessage(merge.localPath)
+                : diagnosticMessage;
+
             const range = new vscode.Range(startLine, startCharacter, startLine, endCharacter);
-            const entry = new vscode.Diagnostic(range, message, severity);
+            const entry = new vscode.Diagnostic(range, normalizedMessage, severity);
             entry.source = 'csolution';
 
             if (!line && !column) {
-                // add 'Find in Files' action only if no line/column info is available
-                const args = this.createQueryArgs(message);
-                if (args) {
+                // add merge action first, fallback to 'Find in Files' if not a merge advisory
+                if (merge) {
+                    const commandUri = createMergeCommandUri(merge.localPath);
                     entry.code = {
-                        value: 'Find in Files',
-                        target: vscode.Uri.parse(`command:workbench.action.findInFiles?${args}`)
+                        value: MERGE_VIEW_LINK_LABEL,
+                        target: vscode.Uri.parse(commandUri),
                     };
+                } else {
+                    const args = this.createQueryArgs(diagnosticMessage);
+                    if (args) {
+                        entry.code = {
+                            value: 'Find in Files',
+                            target: vscode.Uri.parse(`command:workbench.action.findInFiles?${args}`)
+                        };
+                    }
                 }
             }
 

src/views/solution-outline/commands/merge-command.test.ts

@@ -45,6 +45,7 @@ import * as fs from 'fs';
 import * as child_process from 'child_process';
 import * as os from 'os';
 import * as path from 'path';
+import { MergeNodeResolver } from '../merge-node-resolver';
 
 jest.mock('fs');
 jest.mock('child_process');
@@ -93,11 +94,51 @@ describe('MergeCommand', () => {
     it('registers the command on activation', async () => {
         await command.activate(extensionContextFactory());
 
-        expect(commandsProvider.registerCommand).toHaveBeenCalledTimes(1);
+        expect(commandsProvider.registerCommand).toHaveBeenCalledTimes(2);
         expect(commandsProvider.registerCommand).toHaveBeenCalledWith(MergeCommand.mergeFile, expect.any(Function), expect.anything());
+        expect(commandsProvider.registerCommand).toHaveBeenCalledWith(MergeCommand.mergeFileFromPath, expect.any(Function), expect.anything());
     });
 
     describe('cross-platform', () => {
+        it('shows error when merge path is missing', async () => {
+            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
+
+            await command['runVSCodeMergeFromPath']('');
+
+            expect(showErrorMessageSpy).toHaveBeenCalledWith('Cannot open merge view: merge file path is missing.');
+        });
+
+        it('shows error when merge node resolver has no match', async () => {
+            const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
+            const resolver: MergeNodeResolver = {
+                setTreeRoot: jest.fn(),
+                findMergeNodeByLocalPath: jest.fn().mockReturnValue(undefined),
+            };
+            const commandWithResolver = new MergeCommand(commandsProvider, activeSolutionTracker, resolver);
+
+            await commandWithResolver['runVSCodeMergeFromPath']('C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+            expect(showErrorMessageSpy).toHaveBeenCalledWith('Cannot open merge view: merge metadata not available. Reload solution and try again.');
+        });
+
+        it('resolves node by path and delegates to merge flow', async () => {
+            const resolverNode = new COutlineItem('file');
+            const resolver: MergeNodeResolver = {
+                setTreeRoot: jest.fn(),
+                findMergeNodeByLocalPath: jest.fn().mockReturnValue(resolverNode),
+            };
+            const commandWithResolver = new MergeCommand(commandsProvider, activeSolutionTracker, resolver);
+            const commandWithResolverPrivate = commandWithResolver as unknown as {
+                runVSCodeMerge: (node: COutlineItem) => Promise<void>;
+            };
+            const runVSCodeMergeSpy = jest.spyOn(commandWithResolverPrivate, 'runVSCodeMerge').mockResolvedValue(undefined);
+
+            await commandWithResolver['runVSCodeMergeFromPath']('C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+            expect(resolver.findMergeNodeByLocalPath).toHaveBeenCalled();
+            expect(runVSCodeMergeSpy).toHaveBeenCalledWith(resolverNode);
+        });
+
         it('shows error if node is not passed', async () => {
             const showErrorMessageSpy = jest.spyOn(vscode.window, 'showErrorMessage');
             // @ts-expect-error - testing behavior when `runVSCodeMerge` receives null

src/views/solution-outline/commands/merge-command.ts

@@ -23,24 +23,46 @@ import path from 'path';
 import * as os from 'os';
 import * as fs from 'fs';
 import { ActiveSolutionTracker } from '../../../solutions/active-solution-tracker';
+import { MergeNodeResolver } from '../merge-node-resolver';
 
 export class MergeCommand {
     public static readonly mergeFile = `${PACKAGE_NAME}.mergeFile`;
+    public static readonly mergeFileFromPath = `${PACKAGE_NAME}.mergeFileFromPath`;
     private static readonly disallowedCmdChars  = /[\r\n&|<>^%"']/;
 
     constructor(
         private readonly commandsProvider: CommandsProvider,
-        private readonly activeSolutionTracker: ActiveSolutionTracker
+        private readonly activeSolutionTracker: ActiveSolutionTracker,
+        private readonly mergeNodeResolver?: MergeNodeResolver,
     ) { }
 
     public async activate(context: Pick<vscode.ExtensionContext, 'subscriptions'>) {
         context.subscriptions.push(
             this.commandsProvider.registerCommand(MergeCommand.mergeFile, (node: COutlineItem) => {
                 this.runVSCodeMerge(node);
             }, this),
+            this.commandsProvider.registerCommand(MergeCommand.mergeFileFromPath, (localPath: string) => {
+                this.runVSCodeMergeFromPath(localPath);
+            }, this),
         );
     }
 
+    private async runVSCodeMergeFromPath(localPath: string): Promise<void> {
+        if (!localPath) {
+            vscode.window.showErrorMessage('Cannot open merge view: merge file path is missing.');
+            return;
+        }
+
+        const normalizedPath = path.resolve(localPath);
+        const node = this.mergeNodeResolver?.findMergeNodeByLocalPath(normalizedPath);
+        if (!node) {
+            vscode.window.showErrorMessage('Cannot open merge view: merge metadata not available. Reload solution and try again.');
+            return;
+        }
+
+        await this.runVSCodeMerge(node);
+    }
+
     private async runVSCodeMerge(node: COutlineItem): Promise<void> {
         if (!node) {
             vscode.window.showErrorMessage('File data is not available for merge operation.');

src/views/solution-outline/commands/merge-message-parser.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2026 Arm Limited
+ *
+ * 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
+ *
+ *     https://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 { createMergeCommandUri, createMergeDiagnosticMessage, MERGE_VIEW_LINK_LABEL, parseMergeMessage } from './merge-message-parser';
+
+describe('merge-message-parser', () => {
+    it.each([
+        'required',
+        'recommended',
+        'suggested',
+        'mandatory',
+    ])('parses merge advisory message for status %s', (status) => {
+        const line = `file 'C:/workspace/RTE/CMSIS/RTX_Config.c' update ${status}; merge content from update file, rename update file to base file and remove previous base file`;
+
+        const parsed = parseMergeMessage(line);
+
+        expect(parsed).toEqual(expect.objectContaining({
+            localPath: 'C:/workspace/RTE/CMSIS/RTX_Config.c',
+        }));
+        expect(parsed?.matchLength).toBeGreaterThan(0);
+    });
+
+    it('returns undefined for non-merge message', () => {
+        expect(parseMergeMessage('warning: unrelated diagnostic')).toBeUndefined();
+    });
+
+    it('creates merge command uri with encoded path argument', () => {
+        const uri = createMergeCommandUri('C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+        expect(uri).toContain('command:cmsis-csolution.mergeFileFromPath?');
+        expect(decodeURIComponent(uri.split('?')[1])).toBe('["C:/workspace/RTE/CMSIS/RTX_Config.c"]');
+    });
+
+    it('creates concise problems-view message', () => {
+        const message = createMergeDiagnosticMessage('C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+        expect(message).toBe('RTX_Config.c has a new version available for merge.');
+        expect(message).not.toContain(MERGE_VIEW_LINK_LABEL);
+    });
+});

src/views/solution-outline/commands/merge-message-parser.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright 2026 Arm Limited
+ *
+ * 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
+ *
+ *     https://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 path from 'node:path';
+
+export const MERGE_VIEW_LINK_LABEL = 'Open Merge View';
+
+const mergeMessageRegex = /file\s+'([^']+)'\s+update\s+(?:required|recommended|suggested|mandatory);\s*merge content from update file/i;
+
+export interface MergeMessageMatch {
+    localPath: string;
+    matchStart: number;
+    matchLength: number;
+}
+
+export function parseMergeMessage(line: string): MergeMessageMatch | undefined {
+    const match = mergeMessageRegex.exec(line);
+    if (!match || match.index === undefined) {
+        return undefined;
+    }
+
+    return {
+        localPath: match[1],
+        matchStart: match.index,
+        matchLength: match[0].length,
+    };
+}
+
+export function createMergeCommandUri(localPath: string): string {
+    const commandId = 'cmsis-csolution.mergeFileFromPath';
+    const args = encodeURIComponent(JSON.stringify([localPath]));
+    return `command:${commandId}?${args}`;
+}
+
+export function createMergeDiagnosticMessage(localPath: string): string {
+    return `${path.basename(localPath)} has a new version available for merge.`;
+}

src/views/solution-outline/merge-node-resolver.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2026 Arm Limited
+ *
+ * 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
+ *
+ *     https://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 manifest from '../../manifest';
+import { COutlineItem } from './tree-structure/solution-outline-item';
+import { MergeNodeResolverImpl } from './merge-node-resolver';
+
+describe('MergeNodeResolverImpl', () => {
+    it('returns undefined when tree root is not set', () => {
+        const resolver = new MergeNodeResolverImpl();
+
+        expect(resolver.findMergeNodeByLocalPath('C:/workspace/RTX_Config.c')).toBeUndefined();
+    });
+
+    it('finds merge-enabled file node by local path', () => {
+        const root = new COutlineItem('root');
+        const group = root.createChild('group');
+        const mergeFile = group.createChild('file');
+        mergeFile.addFeature(manifest.MERGE_FILE_CONTEXT);
+        mergeFile.setAttribute('local', 'C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+        const resolver = new MergeNodeResolverImpl();
+        resolver.setTreeRoot(root);
+
+        const found = resolver.findMergeNodeByLocalPath('C:/workspace/RTE/CMSIS/RTX_Config.c');
+        expect(found).toBe(mergeFile);
+    });
+
+    it('ignores file node without merge feature even if local path matches', () => {
+        const root = new COutlineItem('root');
+        const file = root.createChild('file');
+        file.setAttribute('local', 'C:/workspace/RTE/CMSIS/RTX_Config.c');
+
+        const resolver = new MergeNodeResolverImpl();
+        resolver.setTreeRoot(root);
+
+        expect(resolver.findMergeNodeByLocalPath('C:/workspace/RTE/CMSIS/RTX_Config.c')).toBeUndefined();
+    });
+});