Add edit to group context menu

Author: maribelguzmanm

package.json

@@ -784,6 +784,10 @@
         "command": "cmsis-csolution.list.find",
         "title": "Search"
       },
+      {
+        "command": "cmsis-csolution.edit",
+        "title": "Edit"
+      },
       {
         "command": "cmsis-csolution.showSolutionOutline",
         "title": "Show Solution Outline"
@@ -929,6 +933,10 @@
           "command": "cmsis-csolution.addToGroup",
           "when": "false"
         },
+        {
+          "command": "cmsis-csolution.edit",
+          "when": "false"
+        },
         {
           "command": "cmsis-csolution.showConfigWizardPreview",
           "when": "false"
@@ -1145,6 +1153,11 @@
           "when": "view == cmsis-csolution.outline && viewItem =~ /group|file/",
           "group": "contextMenu"
         },
+        {
+          "command": "cmsis-csolution.edit",
+          "when": "view == cmsis-csolution.outline && viewItem =~ /group/",
+          "group": "contextMenu"
+        },
         {
           "command": "cmsis-csolution.runGenerator",
           "when": "view == cmsis-csolution.outline && viewItem =~ /component-gen/",

src/desktop/extension.ts

@@ -55,6 +55,7 @@ import { CreateSolutionWebviewMain } from '../views/create-solutions/create-solu
 import { ManageLayersWebviewMain } from '../views/manage-layers/manage-layers-webview-main';
 import { AddToGroupCommand } from '../views/solution-outline/commands/add-to-group-command';
 import { DeleteCommand } from '../views/solution-outline/commands/delete-command';
+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';
@@ -210,6 +211,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
 
     const addToGroupCommand = new AddToGroupCommand(workspaceFsProvider, commandsProvider, solutionManager);
     const deleteCommand = new DeleteCommand(commandsProvider, workspaceFsProvider);
+    const editCommand = new EditCommand(commandsProvider);
     const copyHeaderCommand = new CopyHeaderCommand(commandsProvider);
     const openCommand = new OpenCommand(solutionManager, commandsProvider, externalFileOpener);
     const findCommand = new FindCommand(commandsProvider);
@@ -273,6 +275,7 @@ export const activate = async (context: ExtensionContext): Promise<CsolutionExte
         solutionLanguageFeatures.activate(context),
         addToGroupCommand.activate(context),
         deleteCommand.activate(context),
+        editCommand.activate(context),
         copyHeaderCommand.activate(context),
         openCommand.activate(context),
         findCommand.activate(context),

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

@@ -0,0 +1,101 @@
+/**
+ * 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 vscode from 'vscode';
+import * as yaml from 'yaml';
+import { CommandsProvider } from '../../../vscode-api/commands-provider';
+import * as manifest from '../../../manifest';
+import { COutlineItem } from '../tree-structure/solution-outline-item';
+import { getGroupPathArray } from '../utils';
+import { buildPathFromContentToGroup } from '../../../solutions/edit/manage-group-items';
+import { getYamlNodeAtPath, listItem, mapKey } from '../../../solutions/edit/edit-yaml';
+import { readTextFile } from '../../../utils/fs-utils';
+
+export class EditCommand {
+    public static readonly editCommandId = `${manifest.PACKAGE_NAME}.edit`;
+
+    constructor(
+        private readonly commandsProvider: CommandsProvider,
+    ) { }
+
+    public async activate(context: Pick<vscode.ExtensionContext, 'subscriptions'>) {
+        context.subscriptions.push(
+            this.commandsProvider.registerCommand(EditCommand.editCommandId, async (node: COutlineItem) => {
+                await this.editGroup(node);
+            }, this),
+        );
+    }
+
+    private async editGroup(node: COutlineItem): Promise<void> {
+        if (node.getTag() !== 'group') {
+            return;
+        }
+
+        const filePath = node.originFilePath;
+        if (!filePath) {
+            return;
+        }
+
+        const groupPath = getGroupPathArray(node);
+        if (groupPath.length === 0) {
+            return;
+        }
+
+        const parentType = this.getParentTypeFromNode(node);
+        const offset = this.findGroupOffset(filePath, parentType, groupPath) ?? 0;
+
+        const document = await vscode.workspace.openTextDocument(vscode.Uri.file(filePath));
+        const position = document.positionAt(offset);
+        await vscode.window.showTextDocument(document, {
+            selection: new vscode.Range(position, position),
+            preview: false,
+        });
+    }
+
+    private findGroupOffset(filePath: string, parentType: 'project' | 'layer', groupPath: string[]): number | undefined {
+        const input = readTextFile(filePath);
+        if (!input) {
+            return undefined;
+        }
+
+        const yamlDocument = yaml.parseDocument(input);
+        const contents = yamlDocument.contents;
+        if (!contents) {
+            return undefined;
+        }
+
+        const targetGroupName = groupPath[groupPath.length - 1];
+        if (!targetGroupName) {
+            return undefined;
+        }
+
+        const pathToParentGroup = buildPathFromContentToGroup(groupPath.slice(0, -1), [mapKey(parentType)]);
+        const pathToTargetGroup = [
+            ...pathToParentGroup,
+            mapKey('groups'),
+            listItem(item => yaml.isMap(item) && item.get('group') === targetGroupName),
+        ];
+
+        const targetGroupNode = getYamlNodeAtPath(contents, pathToTargetGroup);
+        return (targetGroupNode && yaml.isNode(targetGroupNode) && targetGroupNode.range)
+            ? targetGroupNode.range[0]
+            : undefined;
+    }
+
+    private getParentTypeFromNode(node: COutlineItem): 'project' | 'layer' {
+        return node.getAttribute('layerUri') ? 'layer' : 'project';
+    }
+}

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

@@ -23,6 +23,7 @@ import { SolutionManager } from '../../../solutions/solution-manager';
 import { IOpenFileExternal } from '../../../open-file-external-if';
 import { contextDescriptorFromString } from '../../../solutions/descriptors/descriptors';
 import { existsSync } from 'fs';
+import { lineOf, readTextFile } from '../../../utils/fs-utils';
 
 
 export class OpenCommand {
@@ -83,11 +84,26 @@ export class OpenCommand {
     private async commandHandler(command: string, node: COutlineItem) {
         const filePath = this.getFilePathForCommand(command, node);
         if (filePath) {
+            if (command === OpenCommand.openProjectCommandId) {
+                this.openProjectFile(filePath);
+                return;
+            }
+
             const openExternal = command === OpenCommand.openDocCommandId;
             this.openFile(filePath, openExternal);
         }
     }
 
+    private async openProjectFile(filePath: string): Promise<void> {
+        const projectLine = lineOf(readTextFile(filePath), 'project:');
+        const document = await vscode.workspace.openTextDocument(vscode.Uri.file(filePath));
+        const position = new vscode.Position(projectLine, 0);
+        await vscode.window.showTextDocument(document, {
+            selection: new vscode.Range(position, position),
+            preview: false,
+        });
+    }
+
     private getFilePathForCommand(command: string, node: COutlineItem): string | undefined {
         if (command === OpenCommand.openDocCommandId) {
             return node.getAttribute('docPath');