Add edit to file context menu

Author: maribelguzmanm

package.json

@@ -1155,7 +1155,7 @@
         },
         {
           "command": "cmsis-csolution.edit",
-          "when": "view == cmsis-csolution.outline && viewItem =~ /group/",
+          "when": "view == cmsis-csolution.outline && viewItem =~ /group|file/",
           "group": "contextMenu"
         },
         {

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

@@ -0,0 +1,125 @@
+/**
+ * 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 fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import * as vscode from 'vscode';
+import { EditCommand } from './edit-command';
+import { extensionContextFactory } from '../../../vscode-api/extension-context.factories';
+import { commandsProviderFactory, MockCommandsProvider } from '../../../vscode-api/commands-provider.factories';
+import { COutlineItem } from '../tree-structure/solution-outline-item';
+
+describe('EditCommand', () => {
+    let commandsProvider: MockCommandsProvider;
+    let tmpDir: string;
+    let cprojectPath: string;
+    let yamlContent: string;
+    let positionAt: jest.Mock;
+
+    beforeEach(() => {
+        commandsProvider = commandsProviderFactory();
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-command-'));
+        cprojectPath = path.join(tmpDir, 'test.cproject.yml');
+
+        yamlContent = `project:
+  groups:
+    - group: App
+      files:
+        - file: src/main.c
+      groups:
+        - group: Drivers
+          files:
+            - file: drv.c
+`;
+
+        fs.writeFileSync(cprojectPath, yamlContent, 'utf8');
+
+        positionAt = jest.fn().mockReturnValue(new vscode.Position(0, 0));
+        jest.spyOn(vscode.workspace, 'openTextDocument').mockResolvedValue({ positionAt } as unknown as vscode.TextDocument);
+        jest.spyOn(vscode.window, 'showTextDocument').mockResolvedValue({} as vscode.TextEditor);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('registers the edit command on activation', async () => {
+        const editCommand = new EditCommand(commandsProvider);
+
+        await editCommand.activate(extensionContextFactory());
+
+        expect(commandsProvider.registerCommand).toHaveBeenCalledWith(
+            EditCommand.editCommandId,
+            expect.any(Function),
+            editCommand,
+        );
+    });
+
+    it('opens cproject.yml at the selected group entry', async () => {
+        const editCommand = new EditCommand(commandsProvider);
+        await editCommand.activate(extensionContextFactory());
+
+        const groupNode = new COutlineItem('group');
+        groupNode.setAttribute('groupPath', 'App;Drivers');
+        groupNode.setAttribute('projectUri', cprojectPath);
+
+        await commandsProvider.mockRunRegistered(EditCommand.editCommandId, groupNode);
+
+        expect(vscode.workspace.openTextDocument).toHaveBeenCalledWith(vscode.Uri.file(cprojectPath));
+        expect(positionAt).toHaveBeenCalledTimes(1);
+        const actualOffset = positionAt.mock.calls[0][0] as number;
+        expect(actualOffset).toBeGreaterThanOrEqual(0);
+        expect(yamlContent.slice(actualOffset)).toContain('group: Drivers');
+        expect(vscode.window.showTextDocument).toHaveBeenCalled();
+    });
+
+    it('opens cproject.yml at the selected file entry', async () => {
+        const editCommand = new EditCommand(commandsProvider);
+        await editCommand.activate(extensionContextFactory());
+
+        const groupNode = new COutlineItem('group');
+        groupNode.setAttribute('groupPath', 'App;Drivers');
+        groupNode.setAttribute('projectUri', cprojectPath);
+
+        const fileNode = groupNode.createChild('file');
+        fileNode.setAttribute('projectUri', cprojectPath);
+        fileNode.setAttribute('fileUri', 'drv.c');
+
+        await commandsProvider.mockRunRegistered(EditCommand.editCommandId, fileNode);
+
+        expect(vscode.workspace.openTextDocument).toHaveBeenCalledWith(vscode.Uri.file(cprojectPath));
+        expect(positionAt).toHaveBeenCalledTimes(1);
+        const actualOffset = positionAt.mock.calls[0][0] as number;
+        expect(actualOffset).toBeGreaterThanOrEqual(0);
+        expect(yamlContent.slice(actualOffset)).toContain('file: drv.c');
+        expect(vscode.window.showTextDocument).toHaveBeenCalled();
+    });
+
+    it('ignores file nodes outside editable groups', async () => {
+        const editCommand = new EditCommand(commandsProvider);
+        await editCommand.activate(extensionContextFactory());
+
+        const nonEditableNode = new COutlineItem('file');
+        nonEditableNode.setAttribute('fileUri', 'out/test.map');
+
+        await commandsProvider.mockRunRegistered(EditCommand.editCommandId, nonEditableNode);
+
+        expect(vscode.workspace.openTextDocument).not.toHaveBeenCalled();
+        expect(vscode.window.showTextDocument).not.toHaveBeenCalled();
+    });
+});

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

@@ -34,13 +34,14 @@ export class EditCommand {
     public async activate(context: Pick<vscode.ExtensionContext, 'subscriptions'>) {
         context.subscriptions.push(
             this.commandsProvider.registerCommand(EditCommand.editCommandId, async (node: COutlineItem) => {
-                await this.editGroup(node);
+                await this.editNode(node);
             }, this),
         );
     }
 
-    private async editGroup(node: COutlineItem): Promise<void> {
-        if (node.getTag() !== 'group') {
+    private async editNode(node: COutlineItem): Promise<void> {
+        const tag = node.getTag();
+        if (tag !== 'group' && tag !== 'file') {
             return;
         }
 
@@ -49,13 +50,19 @@ export class EditCommand {
             return;
         }
 
-        const groupPath = getGroupPathArray(node);
+        const groupPath = this.getGroupPathForNode(node);
         if (groupPath.length === 0) {
             return;
         }
 
         const parentType = this.getParentTypeFromNode(node);
-        const offset = this.findGroupOffset(filePath, parentType, groupPath) ?? 0;
+        const offset = tag === 'group'
+            ? this.findGroupOffset(filePath, parentType, groupPath)
+            : this.findFileOffset(filePath, parentType, groupPath, node.getAttribute('fileUri'));
+
+        if (offset === undefined) {
+            return;
+        }
 
         const document = await vscode.workspace.openTextDocument(vscode.Uri.file(filePath));
         const position = document.positionAt(offset);
@@ -65,6 +72,19 @@ export class EditCommand {
         });
     }
 
+    private getGroupPathForNode(node: COutlineItem): string[] {
+        if (node.getTag() === 'group') {
+            return getGroupPathArray(node);
+        }
+
+        const parent = node.getParent();
+        if (!parent || !(parent instanceof COutlineItem) || parent.getTag() !== 'group') {
+            return [];
+        }
+
+        return getGroupPathArray(parent);
+    }
+
     private findGroupOffset(filePath: string, parentType: 'project' | 'layer', groupPath: string[]): number | undefined {
         const input = readTextFile(filePath);
         if (!input) {
@@ -95,6 +115,34 @@ export class EditCommand {
             : undefined;
     }
 
+    private findFileOffset(filePath: string, parentType: 'project' | 'layer', groupPath: string[], fileUri?: string): number | undefined {
+        if (!fileUri) {
+            return undefined;
+        }
+
+        const input = readTextFile(filePath);
+        if (!input) {
+            return undefined;
+        }
+
+        const yamlDocument = yaml.parseDocument(input);
+        const contents = yamlDocument.contents;
+        if (!contents) {
+            return undefined;
+        }
+
+        const pathToTargetFile = [
+            ...buildPathFromContentToGroup(groupPath, [mapKey(parentType)]),
+            mapKey('files'),
+            listItem(item => yaml.isMap(item) && item.get('file') === fileUri),
+        ];
+
+        const targetFileNode = getYamlNodeAtPath(contents, pathToTargetFile);
+        return (targetFileNode && yaml.isNode(targetFileNode) && targetFileNode.range)
+            ? targetFileNode.range[0]
+            : undefined;
+    }
+
     private getParentTypeFromNode(node: COutlineItem): 'project' | 'layer' {
         return node.getAttribute('layerUri') ? 'layer' : 'project';
     }