Feature: show plugins and clients in panel

src/kiota/Rpc/IServer.cs

@@ -14,4 +14,6 @@ internal interface IServer
     Task<LanguagesInformation> InfoForDescriptionAsync(string descriptionPath, bool clearCache, CancellationToken cancellationToken);
     Task<List<LogEntry>> GeneratePluginAsync(string openAPIFilePath, string outputPath, PluginType[] pluginTypes, string[] includePatterns, string[] excludePatterns, string clientClassName, bool cleanOutput, bool clearCache, string[] disabledValidationRules, ConsumerOperation operation, CancellationToken cancellationToken);
     Task<List<LogEntry>> MigrateFromLockFileAsync(string lockDirectoryPath, CancellationToken cancellationToken);
+    Task<List<LogEntry>> RemoveClientAsync(string clientName, bool cleanOutput, CancellationToken cancellationToken);
+    Task<List<LogEntry>> RemovePluginAsync(string pluginName, bool cleanOutput, CancellationToken cancellationToken);
 }

src/kiota/Rpc/Server.cs

@@ -299,4 +299,29 @@ private static string NormalizeSlashesInPath(string path)
             return path.Replace('/', '\\');
         return path.Replace('\\', '/');
     }
+
+    public Task<List<LogEntry>> RemoveClientAsync(string clientName, bool cleanOutput, CancellationToken cancellationToken)
+    => RemoveClientOrPluginAsync(clientName, cleanOutput, "Client", (workspaceManagementService, clientName, cleanOutput, cancellationToken) => workspaceManagementService.RemoveClientAsync(clientName, cleanOutput, cancellationToken), cancellationToken);
+
+    private static async Task<List<LogEntry>> RemoveClientOrPluginAsync(string clientName, bool cleanOutput, string typeName, Func<WorkspaceManagementService, string, bool, CancellationToken, Task> removal, CancellationToken cancellationToken)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(clientName);
+        ArgumentException.ThrowIfNullOrEmpty(typeName);
+        ArgumentNullException.ThrowIfNull(removal);
+        var logger = new ForwardedLogger<KiotaBuilder>();
+        try
+        {
+            var workspaceManagementService = new WorkspaceManagementService(logger, httpClient, IsConfigPreviewEnabled.Value);
+            await removal(workspaceManagementService, clientName, cleanOutput, cancellationToken).ConfigureAwait(false);
+            logger.LogInformation("{TypeName} {ClientName} removed successfully!", typeName, clientName);
+        }
+        catch (Exception ex)
+        {
+            logger.LogCritical(ex, "error removing the {TypeName}: {ExceptionMessage}", typeName.ToLowerInvariant(), ex.Message);
+        }
+        return logger.LogEntries;
+    }
+
+    public async Task<List<LogEntry>> RemovePluginAsync(string pluginName, bool cleanOutput, CancellationToken cancellationToken)
+    => await RemoveClientOrPluginAsync(pluginName, cleanOutput, "Plugin", (workspaceManagementService, pluginName, cleanOutput, cancellationToken) => workspaceManagementService.RemovePluginAsync(pluginName, cleanOutput, cancellationToken), cancellationToken);
 }

vscode/microsoft-kiota/package.json

@@ -3,8 +3,8 @@
   "displayName": "Microsoft Kiota",
   "publisher": "ms-graph",
   "description": "Client generator for HTTP REST APIs described by OpenAPI which helps eliminate the need to take a dependency on a different API client for every API that you need to call, as well as limiting the generation to the exact API surface area you're interested in, thanks to a filtering capability.",
-  "version": "1.18.100000001",
-  "kiotaVersion": "1.18.0",
+  "version": "1.21.100000001",
+  "kiotaVersion": "1.21.0",
   "telemetryInstrumentationKey": "4c6357e0-daf9-42b5-bdfb-67878f8957b5",
   "icon": "images/logo.png",
   "engines": {
@@ -217,12 +217,14 @@
     "views": {
       "kiota-openapi-explorer": [
         {
-          "id": "kiota.openApiExplorer",
-          "name": "%kiota.openApiExplorer.name%"
+          "id": "kiota.workspace",
+          "name": "%kiota.workspace.name%",
+          "order": 1
         },
         {
-          "id": "kiota.workspace",
-          "name": "%kiota.workspace.name%"
+          "id": "kiota.openApiExplorer",
+          "name": "%kiota.openApiExplorer.name%",
+          "order": 2
         }
       ],
       "kiota-dependencies-info": [
@@ -301,6 +303,16 @@
           "command": "kiota.openApiExplorer.removeAllFromSelectedEndpoints",
           "when": "view == kiota.openApiExplorer && viewItem != clientNameOrPluginName",
           "group": "inline@5"
+        },
+        {
+          "command": "kiota.workspace.selectItem",
+          "when": "viewItem == item",
+          "group": "inline@1"
+        },
+        {
+          "command": "kiota.workspace.deleteItem",
+          "when": "viewItem == item",
+          "group": "inline@2"
         }
       ],
       "commandPalette": [
@@ -437,6 +449,18 @@
       {
         "command": "kiota.migrateFromLockFile",
         "title": "%kiota.migrateClients.title%"
+      },
+      {
+        "command": "kiota.workspace.selectItem",
+        "title": "%kiota.openApiExplorer.editPaths.title%",
+        "category": "Kiota",
+        "icon": "$(bracket)"
+      },
+      {
+        "command": "kiota.workspace.deleteItem",
+        "title": "%kiota.openApiExplorer.removeFromSelectedEndpoints.title%",
+        "category": "Kiota",
+        "icon": "$(trash)"
       }
     ],
     "languages": [

vscode/microsoft-kiota/package.nls.json

@@ -29,7 +29,7 @@
   "kiota.openApiExplorer.openFile.title": "Open file",
   "kiota.workspace.name": "My Workspace",
   "kiota.openApiExplorer.regenerateButton.title": "Re-generate",
-  "kiota.openApiExplorer.editPaths.title": "Edit paths",
+  "kiota.openApiExplorer.editPaths.title": "Select",
   "kiota.openApiExplorer.refresh.title": "Refresh",
   "kiota.migrateClients.title": "Migrate API clients"
 }

vscode/microsoft-kiota/src/commands/deleteWorkspaceItem/deleteWorkspaceItemCommand.ts

@@ -0,0 +1,80 @@
+import TelemetryReporter from "@vscode/extension-telemetry";
+import * as vscode from "vscode";
+
+import { extensionId } from "../../constants";
+import { getLogEntriesForLevel, KiotaLogEntry, LogLevel } from "../../kiotaInterop";
+import { WorkspaceTreeItem } from "../../providers/workspaceTreeProvider";
+import { isPluginType } from "../../util";
+import { exportLogsAndShowErrors } from "../../utilities/logging";
+import { Command } from "../Command";
+import { removeClient, removePlugin } from "./removeItem";
+
+export class DeleteWorkspaceItemCommand extends Command {
+  constructor(
+    private _context: vscode.ExtensionContext,
+    private _kiotaOutputChannel: vscode.LogOutputChannel
+  ) {
+    super();
+  }
+
+  public getName(): string {
+    return `${extensionId}.workspace.deleteItem`;
+  }
+
+  public async execute(workspaceTreeItem: WorkspaceTreeItem): Promise<void> {
+    const type = workspaceTreeItem.category && isPluginType(workspaceTreeItem.category) ? "plugin" : "client";
+    const yesAnswer: vscode.MessageItem = { title: vscode.l10n.t("Yes") };
+    const noAnswer: vscode.MessageItem = { title: vscode.l10n.t("No") };
+
+    const response = await vscode.window.showWarningMessage(
+      vscode.l10n.t("Do you want to delete this item?"),
+      yesAnswer,
+      noAnswer
+    );
+
+    if (response?.title === yesAnswer.title) {
+      const result = await this.deleteItem(type, workspaceTreeItem);
+      if (result) {
+        const isSuccess = result.some(k => k.message.includes('removed successfully'));
+        if (isSuccess) {
+          void vscode.window.showInformationMessage(vscode.l10n.t('{0} removed successfully.', workspaceTreeItem.label));
+          await vscode.commands.executeCommand('kiota.workspace.refresh');
+        } else {
+          await exportLogsAndShowErrors(result, this._kiotaOutputChannel);
+        }
+      }
+    }
+  }
+
+  private async deleteItem(type: string, workspaceTreeItem: WorkspaceTreeItem): Promise<KiotaLogEntry[] | undefined> {
+    const itemName = workspaceTreeItem.label;
+    const result = await vscode.window.withProgress({
+      location: vscode.ProgressLocation.Notification,
+      cancellable: false,
+      title: vscode.l10n.t(`Removing ${type}...`)
+    }, async (progress, _) => {
+      const start = performance.now();
+      const result = type === "plugin" ? await removePlugin(
+        this._context,
+        itemName,
+        false,
+      ) : await removeClient(
+        this._context,
+        itemName,
+        false,
+      );
+      const duration = performance.now() - start;
+      const errorsCount = result ? getLogEntriesForLevel(result, LogLevel.critical, LogLevel.error).length : 0;
+      const reporter = new TelemetryReporter(this._context.extension.packageJSON.telemetryInstrumentationKey);
+      reporter.sendRawTelemetryEvent(`${extensionId}.remove${type}.completed`, {
+        "pluginType": itemName,
+        "errorsCount": errorsCount.toString(),
+      }, {
+        "duration": duration,
+      });
+      return result;
+    });
+    return result;
+  }
+}
+

vscode/microsoft-kiota/src/commands/deleteWorkspaceItem/removeItem.ts

@@ -0,0 +1,32 @@
+import * as vscode from "vscode";
+import * as rpc from "vscode-jsonrpc/node";
+
+import { connectToKiota, KiotaLogEntry } from "../../kiotaInterop";
+
+export function removePlugin(context: vscode.ExtensionContext, pluginName: string, cleanOutput: boolean): Promise<KiotaLogEntry[] | undefined> {
+  return connectToKiota(context, async (connection) => {
+    const request = new rpc.RequestType2<string, boolean, KiotaLogEntry[], void>(
+      "RemovePlugin"
+    );
+    const result = await connection.sendRequest(
+      request,
+      pluginName,
+      cleanOutput
+    );
+    return result;
+  });
+};
+
+export function removeClient(context: vscode.ExtensionContext, clientName: string, cleanOutput: boolean): Promise<KiotaLogEntry[] | undefined> {
+  return connectToKiota(context, async (connection) => {
+    const request = new rpc.RequestType2<string, boolean, KiotaLogEntry[], void>(
+      "RemoveClient"
+    );
+    const result = await connection.sendRequest(
+      request,
+      clientName,
+      cleanOutput
+    );
+    return result;
+  });
+};

vscode/microsoft-kiota/src/commands/editPathsCommand.ts

@@ -1,3 +1,5 @@
+import * as vscode from "vscode";
+
 import { extensionId, treeViewId } from "../constants";
 import { ClientOrPluginProperties } from "../kiotaInterop";
 import { OpenApiTreeProvider } from "../providers/openApiTreeProvider";
@@ -8,11 +10,8 @@ import { Command } from "./Command";
 
 export class EditPathsCommand extends Command {
 
-  private _openApiTreeProvider: OpenApiTreeProvider;
-
-  public constructor(openApiTreeProvider: OpenApiTreeProvider) {
+  public constructor(private _openApiTreeProvider: OpenApiTreeProvider) {
     super();
-    this._openApiTreeProvider = openApiTreeProvider;
   }
 
   public getName(): string {
@@ -23,6 +22,7 @@ export class EditPathsCommand extends Command {
     await this.loadEditPaths(clientOrPluginKey!, clientOrPluginObject!);
     this._openApiTreeProvider.resetInitialState();
     await updateTreeViewIcons(treeViewId, false, true);
+    await vscode.commands.executeCommand('kiota.workspace.refresh');
   }
 
   private async loadEditPaths(clientOrPluginKey: string, clientOrPluginObject: ClientOrPluginProperties) {

vscode/microsoft-kiota/src/extension.ts

@@ -4,6 +4,7 @@ import TelemetryReporter from '@vscode/extension-telemetry';
 import * as vscode from "vscode";
 
 import { CloseDescriptionCommand } from './commands/closeDescriptionCommand';
+import { DeleteWorkspaceItemCommand } from './commands/deleteWorkspaceItem/deleteWorkspaceItemCommand';
 import { EditPathsCommand } from './commands/editPathsCommand';
 import { GenerateClientCommand } from './commands/generate/generateClientCommand';
 import { displayGenerationResults } from './commands/generate/generation-util';
@@ -27,10 +28,12 @@ import { UriHandler } from './handlers/uriHandler';
 import {
   ClientOrPluginProperties
 } from "./kiotaInterop";
+import { WorkspaceContentService } from './modules/workspace';
 import { CodeLensProvider } from './providers/codelensProvider';
 import { DependenciesViewProvider } from "./providers/dependenciesViewProvider";
 import { OpenApiTreeNode, OpenApiTreeProvider } from "./providers/openApiTreeProvider";
-import { loadTreeView } from './providers/workspaceTreeProvider';
+import { SharedService } from './providers/sharedService';
+import { loadTreeView, WorkspaceTreeItem, WorkspaceTreeProvider } from './providers/workspaceTreeProvider';
 import { getExtensionSettings } from "./types/extensionSettings";
 import { GeneratedOutputState } from './types/GeneratedOutputState';
 import { WorkspaceGenerationContext } from "./types/WorkspaceGenerationContext";
@@ -50,11 +53,14 @@ export async function activate(
   kiotaOutputChannel = vscode.window.createOutputChannel("Kiota", {
     log: true,
   });
-  const openApiTreeProvider = new OpenApiTreeProvider(context, () => getExtensionSettings(extensionId));
+  const sharedService = SharedService.getInstance();
+  const workspaceContentService = new WorkspaceContentService();
+  const openApiTreeProvider = new OpenApiTreeProvider(context, () => getExtensionSettings(extensionId), sharedService);
   const dependenciesInfoProvider = new DependenciesViewProvider(
     context.extensionUri
   );
   const reporter = new TelemetryReporter(context.extension.packageJSON.telemetryInstrumentationKey);
+  const workspaceTreeProvider = new WorkspaceTreeProvider(workspaceContentService, sharedService);
 
   const setWorkspaceGenerationContext = (params: Partial<WorkspaceGenerationContext>) => {
     workspaceGenerationContext = { ...workspaceGenerationContext, ...params };
@@ -76,9 +82,10 @@ export async function activate(
   const closeDescriptionCommand = new CloseDescriptionCommand(openApiTreeProvider);
   const statusCommand = new StatusCommand();
   const selectLockCommand = new SelectLockCommand(openApiTreeProvider);
+  const deleteWorkspaceItemCommand = new DeleteWorkspaceItemCommand(context, kiotaOutputChannel);
   const updateClientsCommand = new UpdateClientsCommand(context, kiotaOutputChannel);
 
-  await loadTreeView(context);
+  await loadTreeView(context, workspaceTreeProvider);
   await checkForLockFileAndPrompt(context);
   let codeLensProvider = new CodeLensProvider();
   context.subscriptions.push(
@@ -125,6 +132,8 @@ export async function activate(
       await regenerateCommand.execute({ clientOrPluginKey, clientOrPluginObject, generationType });
     }),
     registerCommandWithTelemetry(reporter, migrateFromLockFileCommand.getName(), async (uri: vscode.Uri) => await migrateFromLockFileCommand.execute(uri)),
+    registerCommandWithTelemetry(reporter, deleteWorkspaceItemCommand.getName(), async (workspaceTreeItem: WorkspaceTreeItem) => await deleteWorkspaceItemCommand.execute(workspaceTreeItem)),
+
   );
 
   // create a new status bar item that we can now manage

vscode/microsoft-kiota/src/modules/workspace/index.ts

@@ -0,0 +1,9 @@
+import { ClientOrPluginProperties } from "../../kiotaInterop";
+import WorkspaceContentService from "./workspaceContentService";
+
+export interface WorkspaceContent {
+  version: string;
+  clients: Record<string, ClientOrPluginProperties>;
+  plugins: Record<string, ClientOrPluginProperties>;
+}
+export { WorkspaceContentService };

vscode/microsoft-kiota/src/modules/workspace/workspaceContentService.ts

@@ -0,0 +1,43 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+import { WorkspaceContent } from ".";
+import { KIOTA_WORKSPACE_FILE } from "../../constants";
+import { getWorkspaceJsonPath } from '../../util';
+
+class WorkspaceContentService {
+  constructor() { }
+
+  public async load(): Promise<WorkspaceContent | undefined> {
+    const isWorkspacePresent = await this.isKiotaWorkspaceFilePresent();
+    if (!isWorkspacePresent) {
+      return;
+    }
+    try {
+      const workspaceJson = vscode.workspace.textDocuments.find(doc => doc.fileName.endsWith(KIOTA_WORKSPACE_FILE));
+      if (!workspaceJson) {
+        throw new Error('Workspace file not found');
+      }
+      const content = workspaceJson.getText();
+      return JSON.parse(content);
+    } catch (error) {
+      console.error('Error loading workspace.json:', error);
+    }
+  }
+
+  async isKiotaWorkspaceFilePresent(): Promise<boolean> {
+    if (!vscode.workspace.workspaceFolders || vscode.workspace.workspaceFolders.length === 0) {
+      return false;
+    }
+    const workspaceFileDir = path.resolve(getWorkspaceJsonPath());
+    try {
+      await fs.promises.access(workspaceFileDir);
+    } catch (error) {
+      return false;
+    }
+    return true;
+  }
+}
+
+export default WorkspaceContentService;