Add a command listing all the tool names (#741)

* Add a command listing all tool names

* Add --namespace option to scope it down to a specific namespace

* Fix format

* Add --name switch to tool list command to only return tool names

* Update CHANGELOG

* Create a helper function to reuse the namespace filtering logic

* Fix format

* Fix test failure

* remove azmcp prefix

* Fix format

* Update var names

* Update core/Azure.Mcp.Core/src/Areas/Tools/Commands/ToolsListCommand.cs

Co-authored-by: vcolin7 <vicolina@microsoft.com>

* Address review feedbacks

* fix format

* Address more review feedbacks

---------

Co-authored-by: vcolin7 <vicolina@microsoft.com>

Author: fanyang-mono

core/Azure.Mcp.Core/src/Areas/Tools/Commands/ToolsListCommand.cs

@@ -1,9 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System.CommandLine.Parsing;
 using System.Runtime.InteropServices;
 using Azure.Mcp.Core.Areas.Tools.Options;
 using Azure.Mcp.Core.Commands;
+using Azure.Mcp.Core.Extensions;
+using Azure.Mcp.Core.Models;
+using Azure.Mcp.Core.Models.Command;
 using Azure.Mcp.Core.Models.Option;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Microsoft.Extensions.Logging;
@@ -23,7 +27,7 @@ public sealed class ToolsListCommand(ILogger<ToolsListCommand> logger) : BaseCom
         """
         List all available commands and their tools in a hierarchical structure. This command returns detailed information
         about each command, including its name, description, full command path, available subcommands, and all supported
-        arguments. Use this to explore the CLI's functionality or to build interactive command interfaces.
+        arguments. Use --name-only to return only tool names, and --namespace to filter by specific namespaces.
         """;
 
     public override string Title => CommandTitle;
@@ -41,14 +45,19 @@ arguments. Use this to explore the CLI's functionality or to build interactive c
     protected override void RegisterOptions(Command command)
     {
         base.RegisterOptions(command);
-        command.Options.Add(ToolsListOptionDefinitions.Namespaces);
+        command.Options.Add(ToolsListOptionDefinitions.NamespaceMode);
+        command.Options.Add(ToolsListOptionDefinitions.Namespace);
+        command.Options.Add(ToolsListOptionDefinitions.NameOnly);
     }
 
     protected override ToolsListOptions BindOptions(ParseResult parseResult)
     {
+        var namespaces = parseResult.GetValueOrDefault<string[]>(ToolsListOptionDefinitions.Namespace.Name) ?? [];
         return new ToolsListOptions
         {
-            Namespaces = parseResult.GetValueOrDefault(ToolsListOptionDefinitions.Namespaces)
+            NamespaceMode = parseResult.GetValueOrDefault(ToolsListOptionDefinitions.NamespaceMode),
+            NameOnly = parseResult.GetValueOrDefault(ToolsListOptionDefinitions.NameOnly),
+            Namespaces = namespaces.ToList()
         };
     }
 
@@ -59,15 +68,17 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
             var factory = context.GetService<CommandFactory>();
             var options = BindOptions(parseResult);
 
-            // If the --namespaces flag is set, return distinct top‑level namespaces (child groups beneath root 'azmcp').
-            if (options.Namespaces)
+            // If the --namespace-mode flag is set, return distinct top‑level namespaces (e.g. child groups beneath root 'azmcp').
+            if (options.NamespaceMode)
             {
                 var ignored = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "server", "tools" };
                 var surfaced = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "extension" };
                 var rootGroup = factory.RootGroup; // azmcp
 
                 var namespaceCommands = rootGroup.SubGroup
                     .Where(g => !ignored.Contains(g.Name) && !surfaced.Contains(g.Name))
+                    // Apply namespace filtering if specified
+                    .Where(g => options.Namespaces.Count == 0 || options.Namespaces.Contains(g.Name, StringComparer.OrdinalIgnoreCase))
                     .Select(g => new CommandInfo
                     {
                         Name = g.Name,
@@ -82,6 +93,10 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
                 // For commands in the surfaced list, each command is exposed as a separate tool in the namespace mode.
                 foreach (var name in surfaced)
                 {
+                    // Apply namespace filtering for surfaced commands too
+                    if (options.Namespaces.Count > 0 && !options.Namespaces.Contains(name, StringComparer.OrdinalIgnoreCase))
+                        continue;
+
                     var subgroup = rootGroup.SubGroup.FirstOrDefault(g => string.Equals(g.Name, name, StringComparison.OrdinalIgnoreCase));
                     if (subgroup is not null)
                     {
@@ -91,13 +106,49 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
                     }
                 }
 
+                // If --name-only is also specified, return only the names
+                if (options.NameOnly)
+                {
+                    var namespaceNames = namespaceCommands.Select(nc => nc.Command).ToList();
+                    var result = new ToolNamesResult(namespaceNames);
+                    context.Response.Results = ResponseResult.Create(result, ModelsJsonContext.Default.ToolNamesResult);
+                    return context.Response;
+                }
+
                 context.Response.Results = ResponseResult.Create(namespaceCommands, ModelsJsonContext.Default.ListCommandInfo);
                 return context.Response;
             }
 
-            var tools = await Task.Run(() => CommandFactory.GetVisibleCommands(factory.AllCommands)
-                .Select(kvp => CreateCommand(kvp.Key, kvp.Value))
-                .ToList());
+            // If the --name-only flag is set (without namespace mode), return only tool names
+            if (options.NameOnly)
+            {
+                // Get all visible commands and extract their tokenized names (full command paths)
+                var allToolNames = CommandFactory.GetVisibleCommands(factory.AllCommands)
+                    .Select(kvp => kvp.Key) // Use the tokenized key instead of just the command name
+                    .Where(name => !string.IsNullOrEmpty(name));
+
+                // Apply namespace filtering if specified (using underscore separator for tokenized names)
+                allToolNames = ApplyNamespaceFilterToNames(allToolNames, options.Namespaces, CommandFactory.Separator);
+
+                var toolNames = await Task.Run(() => allToolNames
+                    .OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
+                    .ToList());
+
+                var result = new ToolNamesResult(toolNames);
+                context.Response.Results = ResponseResult.Create(result, ModelsJsonContext.Default.ToolNamesResult);
+                return context.Response;
+            }
+
+            // Get all tools with full details
+            var allTools = CommandFactory.GetVisibleCommands(factory.AllCommands)
+                .Select(kvp => CreateCommand(kvp.Key, kvp.Value));
+
+            // Apply namespace filtering if specified
+            var filteredToolNames = ApplyNamespaceFilterToNames(allTools.Select(t => t.Command), options.Namespaces, ' ');
+            var filteredToolNamesSet = filteredToolNames.ToHashSet(StringComparer.OrdinalIgnoreCase);
+            allTools = allTools.Where(tool => filteredToolNamesSet.Contains(tool.Command));
+
+            var tools = await Task.Run(() => allTools.ToList());
 
             context.Response.Results = ResponseResult.Create(tools, ModelsJsonContext.Default.ListCommandInfo);
             return context.Response;
@@ -111,6 +162,19 @@ public override async Task<CommandResponse> ExecuteAsync(CommandContext context,
         }
     }
 
+    private static IEnumerable<string> ApplyNamespaceFilterToNames(IEnumerable<string> names, List<string> namespaces, char separator)
+    {
+        if (namespaces.Count == 0)
+        {
+            return names;
+        }
+
+        var namespacePrefixes = namespaces.Select(ns => $"{ns}{separator}").ToList();
+
+        return names.Where(name =>
+            namespacePrefixes.Any(prefix => name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)));
+    }
+
     private static CommandInfo CreateCommand(string tokenizedName, IBaseCommand command)
     {
         var commandDetails = command.GetCommand();
@@ -122,17 +186,20 @@ private static CommandInfo CreateCommand(string tokenizedName, IBaseCommand comm
                 required: arg.Required))
             .ToList();
 
+        var fullCommand = tokenizedName.Replace(CommandFactory.Separator, ' ');
+
         return new CommandInfo
         {
             Id = command.Id,
             Name = commandDetails.Name,
             Description = commandDetails.Description ?? string.Empty,
-            Command = tokenizedName.Replace(CommandFactory.Separator, ' '),
+            Command = fullCommand,
             Options = optionInfos,
             Metadata = command.Metadata
         };
     }
 
+    public record ToolNamesResult(List<string> Names);
     private void searchCommandInCommandGroup(string commandPrefix, CommandGroup searchedGroup, List<CommandInfo> foundCommands)
     {
         var commands = CommandFactory.GetVisibleCommands(searchedGroup.Commands).Select(kvp =>

core/Azure.Mcp.Core/src/Areas/Tools/Options/ToolsListOptionDefinitions.cs

@@ -5,11 +5,26 @@ namespace Azure.Mcp.Core.Areas.Tools.Options;
 
 public static class ToolsListOptionDefinitions
 {
-    public const string NamespacesOptionName = "namespaces";
+    public const string NamespaceModeOptionName = "namespace-mode";
+    public const string NamespaceOptionName = "namespace";
+    public const string NameOnlyOptionName = "name-only";
 
-    public static readonly Option<bool> Namespaces = new($"--{NamespacesOptionName}")
+    public static readonly Option<bool> NamespaceMode = new($"--{NamespaceModeOptionName}")
     {
         Description = "If specified, returns a list of top-level service namespaces instead of individual tools.",
         Required = false
     };
+
+    public static readonly Option<string[]> Namespace = new($"--{NamespaceOptionName}")
+    {
+        Description = "Filter tools by namespace (e.g., 'storage', 'keyvault'). Can be specified multiple times to include multiple namespaces.",
+        Required = false,
+        AllowMultipleArgumentsPerToken = true
+    };
+
+    public static readonly Option<bool> NameOnly = new($"--{NameOnlyOptionName}")
+    {
+        Description = "If specified, returns only tool names without descriptions or metadata.",
+        Required = false
+    };
 }

core/Azure.Mcp.Core/src/Areas/Tools/Options/ToolsListOptions.cs

@@ -5,5 +5,15 @@ namespace Azure.Mcp.Core.Areas.Tools.Options;
 
 public sealed class ToolsListOptions
 {
-    public bool Namespaces { get; set; } = false;
+    public bool NamespaceMode { get; set; } = false;
+
+    /// <summary>
+    /// If true, returns only tool names without descriptions or metadata.
+    /// </summary>
+    public bool NameOnly { get; set; } = false;
+
+    /// <summary>
+    /// Optional namespaces to filter tools. If provided, only tools from these namespaces will be returned.
+    /// </summary>
+    public List<string> Namespaces { get; set; } = new();
 }

core/Azure.Mcp.Core/src/Models/ModelsJsonContext.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.Text.Json.Serialization;
+using Azure.Mcp.Core.Areas.Tools.Commands;
 using Azure.Mcp.Core.Commands;
 using Azure.Mcp.Core.Models.Elicitation;
 
@@ -13,6 +14,7 @@ namespace Azure.Mcp.Core.Models;
 [JsonSerializable(typeof(ElicitationSchemaRoot))]
 [JsonSerializable(typeof(ElicitationSchemaProperty))]
 [JsonSerializable(typeof(ToolMetadata))]
+[JsonSerializable(typeof(ToolsListCommand.ToolNamesResult))]
 [JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
 public sealed partial class ModelsJsonContext : JsonSerializerContext
 {