Open source file with vscode editor or conf Wizard view

Author: mguzmanm

src/utils/config-wizard-annotation-checker.test.ts

@@ -0,0 +1,85 @@
+/**
+ * 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 'path';
+import { TestDataHandler } from '../__test__/test-data';
+import { writeTextFile } from './fs-utils';
+import { configWizardAnnotationChecker } from './config-wizard-annotation-checker';
+
+describe('configWizardAnnotationChecker', () => {
+    const testDataHandler = new TestDataHandler();
+    let testFolder: string;
+
+    beforeEach(() => {
+        testFolder = testDataHandler.tmpDir;
+    });
+
+    afterEach(() => {
+        testDataHandler.rmTmpDir();
+    });
+
+    afterAll(() => {
+        testDataHandler.dispose();
+    });
+
+    it('returns true when start marker is within first 100 lines', async () => {
+        const filePath = path.join(testFolder, 'within-100.h');
+        const lines = Array.from({ length: 99 }, () => 'int x = 0;');
+        lines.push('// <<< Use Configuration Wizard in Context Menu >>>');
+        writeTextFile(filePath, lines.join('\n'));
+
+        await expect(configWizardAnnotationChecker.hasAnnotations(filePath)).resolves.toBe(true);
+    });
+
+    it('returns false when start marker appears after first 100 lines', async () => {
+        const filePath = path.join(testFolder, 'after-100.h');
+        const lines = Array.from({ length: 100 }, () => 'int y = 1;');
+        lines.push('// <<< Use Configuration Wizard in Context Menu >>>');
+        writeTextFile(filePath, lines.join('\n'));
+
+        await expect(configWizardAnnotationChecker.hasAnnotations(filePath)).resolves.toBe(false);
+    });
+
+    it('returns true when start marker is within first 100 lines and end marker is after 100 lines', async () => {
+        const filePath = path.join(testFolder, 'end-after-100.h');
+        const lines = Array.from({ length: 39 }, () => 'int cfg = 3;');
+        lines.push('// <<< Use Configuration Wizard in Context Menu >>>');
+        lines.push(...Array.from({ length: 90 }, () => 'int body = 4;'));
+        lines.push('// <<< end of configuration section >>>');
+        writeTextFile(filePath, lines.join('\n'));
+
+        await expect(configWizardAnnotationChecker.hasAnnotations(filePath)).resolves.toBe(true);
+    });
+
+    it('returns false when only end marker is present', async () => {
+        const filePath = path.join(testFolder, 'end-only.h');
+        writeTextFile(filePath, '// <<< end of configuration section >>>\nint z = 2;\n');
+
+        await expect(configWizardAnnotationChecker.hasAnnotations(filePath)).resolves.toBe(false);
+    });
+
+    it('returns true for decorated marker lines used in template headers', async () => {
+        const filePath = path.join(testFolder, 'decorated-marker.h');
+        const lines = [
+            '/* header */',
+            '//-------- <<< Use Configuration Wizard in Context Menu >>> --------------------',
+            'int cfg = 0;'
+        ];
+        writeTextFile(filePath, lines.join('\n'));
+
+        await expect(configWizardAnnotationChecker.hasAnnotations(filePath)).resolves.toBe(true);
+    });
+});

src/utils/config-wizard-annotation-checker.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { readTextFile } from './fs-utils';
+
+export interface ConfigWizardAnnotationChecker {
+    hasAnnotations(filePath: string): Promise<boolean>;
+}
+
+class ConfigWizardAnnotationCheckerImpl implements ConfigWizardAnnotationChecker {
+    private static readonly MAX_LINES_TO_SCAN = 100;
+    private static readonly wizardStartMarkerRegex = /^\s*\/\/.*<<<\s*use configuration wizard in context menu\s*>>>.*$/i;
+
+    public async hasAnnotations(filePath: string): Promise<boolean> {
+        const fileContent = readTextFile(filePath);
+        const lines = fileContent.split(/\r?\n/);
+
+        const maxLines = Math.min(ConfigWizardAnnotationCheckerImpl.MAX_LINES_TO_SCAN, lines.length);
+        for (let i = 0; i < maxLines; i++) {
+            if (ConfigWizardAnnotationCheckerImpl.wizardStartMarkerRegex.test(lines[i])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+export const configWizardAnnotationChecker: ConfigWizardAnnotationChecker =
+    new ConfigWizardAnnotationCheckerImpl();

src/utils/config-wizard-checker.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+
+export type { ConfigWizardAnnotationChecker } from './config-wizard-annotation-checker';
+export { configWizardAnnotationChecker } from './config-wizard-annotation-checker';

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

@@ -30,15 +30,20 @@ import type { CTreeItem } from '../../../generic/tree-item';
 import type { CSolution } from '../../../solutions/csolution';
 import { README_FILE_PATH } from '../../../manifest';
 import { faker } from '@faker-js/faker';
+import { ConfigWizardAnnotationChecker } from '../../../utils/config-wizard-checker';
 
 describe('OpenCommand', () => {
     let commandsProvider: MockCommandsProvider;
     const mockOpenFileExternal: IOpenFileExternal = openFileExternalFactory();
+    let mockAnnotationChecker: ConfigWizardAnnotationChecker;
     let testFolder: string;
     let testFile: string;
 
     beforeEach(async () => {
         commandsProvider = commandsProviderFactory();
+        mockAnnotationChecker = {
+            hasAnnotations: jest.fn().mockResolvedValue(false),
+        };
         testFolder = fs.mkdtempSync(path.join(os.tmpdir(), 'jest-'));
         testFile = `${testFolder}/jtest.txt`;
         fs.writeFileSync(testFile, 'test content');
@@ -50,12 +55,12 @@ describe('OpenCommand', () => {
     });
 
     it('registers the command on activation', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
 
         await openCommand.activate(extensionContextFactory());
 
         const expectedCommands = [OpenCommand.openSolutionCommandId, OpenCommand.openProjectCommandId, OpenCommand.openPrjConfCommandId,
-            OpenCommand.openLayerCommandId, OpenCommand.openLinkerCommandId, OpenCommand.openDocCommandId, OpenCommand.openHelpCommandId,
+            OpenCommand.openLayerCommandId, OpenCommand.openLinkerCommandId, OpenCommand.openDocCommandId, OpenCommand.openSourceSmartCommandId, OpenCommand.openHelpCommandId,
             OpenCommand.openZephyrTerminalCommandId];
 
         expect(commandsProvider.registerCommand).toHaveBeenCalledTimes(expectedCommands.length);
@@ -69,7 +74,7 @@ describe('OpenCommand', () => {
         const mockSolutionManager = solutionManagerFactory({
             loadState: activeSolutionLoadStateFactory({ solutionPath: solutionPath }),
         });
-        const openCommand = new OpenCommand(mockSolutionManager, commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(mockSolutionManager, commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
 
         await commandsProvider.mockRunRegistered(OpenCommand.openSolutionCommandId, solutionPath);
@@ -78,7 +83,7 @@ describe('OpenCommand', () => {
     });
 
     it('opens and shows the cproject file from the path', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
         const TEST_PROJECT_PATH = path.join('some', 'path', 'to', 'Test.cproject.yml');
 
@@ -93,7 +98,7 @@ describe('OpenCommand', () => {
     });
 
     it('opens and shows the clayer file from the path', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
         const TEST_LAYER_PATH = path.join('some', 'path', 'to', 'Test.clayer.yml');
 
@@ -108,7 +113,7 @@ describe('OpenCommand', () => {
     });
 
     it('opens and shows the linker map file from the path', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
         const TEST_LINKER_PATH = path.join('some', 'path', 'to', 'myFile.axf.map');
 
@@ -123,7 +128,7 @@ describe('OpenCommand', () => {
     });
 
     it('opens and shows the prj.conf file for West project', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
         const TEST_PRJ_CONF_PATH = path.join('some', 'path', 'to', 'zephyr-app', 'prj.conf');
 
@@ -138,7 +143,7 @@ describe('OpenCommand', () => {
     });
 
     it('opens and shows a doc file from the path', async () => {
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
 
         const fileItem = new COutlineItem('file');
@@ -209,7 +214,7 @@ describe('OpenCommand', () => {
         jest.spyOn(vscode.extensions, 'getExtension').mockReturnValue({ extensionPath } as unknown as vscode.Extension<void>);
         jest.spyOn(fs, 'existsSync').mockReturnValue(true);
 
-        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
 
         jest.spyOn(mockOpenFileExternal, 'openFile');
@@ -228,7 +233,7 @@ describe('OpenCommand', () => {
         const mockSolutionManager = solutionManagerFactory();
         jest.spyOn(mockSolutionManager, 'getCsolution').mockReturnValue({ cbuildYmlRoot: mockCbuildMap } as Partial<CSolution> as CSolution);
 
-        const openCommand = new OpenCommand(mockSolutionManager, commandsProvider, mockOpenFileExternal);
+        const openCommand = new OpenCommand(mockSolutionManager, commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
         await openCommand.activate(extensionContextFactory());
 
         const node = new COutlineItem('project');
@@ -242,4 +247,57 @@ describe('OpenCommand', () => {
         });
         expect(mockTerminal.show).toHaveBeenCalled();
     });
+
+    it('opens candidate source file in configuration wizard when annotations are found', async () => {
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
+        await openCommand.activate(extensionContextFactory());
+        (mockAnnotationChecker.hasAnnotations as jest.Mock).mockResolvedValue(true);
+
+        const uri = Uri.file(path.join(testFolder, 'config.h'));
+        await commandsProvider.mockRunRegistered(OpenCommand.openSourceSmartCommandId, uri);
+
+        const lastCall = commandsProvider.executeCommand.mock.lastCall;
+        expect(lastCall?.[0]).toBe('vscode.openWith');
+        expect((lastCall?.[1] as Uri).fsPath).toBe(uri.fsPath);
+        expect(lastCall?.[2]).toBe('cmsis-csolution.configWizard');
+    });
+
+    it('opens candidate source file in text editor when annotations are missing', async () => {
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
+        await openCommand.activate(extensionContextFactory());
+        (mockAnnotationChecker.hasAnnotations as jest.Mock).mockResolvedValue(false);
+
+        const uri = Uri.file(path.join(testFolder, 'config.h'));
+        await commandsProvider.mockRunRegistered(OpenCommand.openSourceSmartCommandId, uri);
+
+        const lastCall = commandsProvider.executeCommand.mock.lastCall;
+        expect(lastCall?.[0]).toBe('vscode.open');
+        expect((lastCall?.[1] as Uri).fsPath).toBe(uri.fsPath);
+    });
+
+    it('falls back to text editor when annotation detection fails', async () => {
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
+        await openCommand.activate(extensionContextFactory());
+        (mockAnnotationChecker.hasAnnotations as jest.Mock).mockRejectedValue(new Error('parse failure'));
+
+        const uri = Uri.file(path.join(testFolder, 'config.h'));
+        await commandsProvider.mockRunRegistered(OpenCommand.openSourceSmartCommandId, uri);
+
+        const lastCall = commandsProvider.executeCommand.mock.lastCall;
+        expect(lastCall?.[0]).toBe('vscode.open');
+        expect((lastCall?.[1] as Uri).fsPath).toBe(uri.fsPath);
+    });
+
+    it('opens non-candidate source file in text editor without annotation checks', async () => {
+        const openCommand = new OpenCommand(solutionManagerFactory(), commandsProvider, mockOpenFileExternal, mockAnnotationChecker);
+        await openCommand.activate(extensionContextFactory());
+
+        const uri = Uri.file(path.join(testFolder, 'build.txt'));
+        await commandsProvider.mockRunRegistered(OpenCommand.openSourceSmartCommandId, uri);
+
+        expect(mockAnnotationChecker.hasAnnotations).not.toHaveBeenCalled();
+        const lastCall = commandsProvider.executeCommand.mock.lastCall;
+        expect(lastCall?.[0]).toBe('vscode.open');
+        expect((lastCall?.[1] as Uri).fsPath).toBe(uri.fsPath);
+    });
 });