Add shell language support

src/Kiota.Builder/CodeDOM/CodeClass.cs

@@ -6,6 +6,7 @@ namespace Kiota.Builder
 {
     public enum CodeClassKind {
         Custom,
+        CommandBuilder,
         RequestBuilder,
         Model,
         QueryParameters,
@@ -115,6 +116,10 @@ public void AddImplements(params CodeType[] types) {
                 implements.AddRange(types);
             }
             public IEnumerable<CodeType> Implements => implements;
+            public Boolean IsStatic
+            {
+                get; set;
+            }
         }
 
         public class End : BlockEnd

src/Kiota.Builder/CodeDOM/CodeMethod.cs

@@ -18,7 +18,8 @@ public enum CodeMethodKind
         ClientConstructor,
         RequestBuilderBackwardCompatibility,
         RequestBuilderWithParameters,
-        RawUrlConstructor
+        RawUrlConstructor,
+        CommandBuilder
     }
     public enum HttpMethod {
         Get,
@@ -47,6 +48,11 @@ public class CodeMethod : CodeTerminal, ICloneable, IDocumentedElement
         public void RemoveParametersByKind(params CodeParameterKind[] kinds) {
             parameters.RemoveAll(p => p.IsOfKind(kinds));
         }
+
+        public void ClearParameters()
+        {
+            parameters.Clear();
+        }
         public IEnumerable<CodeParameter> Parameters { get => parameters; }
         public bool IsStatic {get;set;} = false;
         public bool IsAsync {get;set;} = true;
@@ -55,6 +61,21 @@ public void RemoveParametersByKind(params CodeParameterKind[] kinds) {
         /// The property this method accesses to when it's a getter or setter.
         /// </summary>
         public CodeProperty AccessedProperty { get; set; }
+        /// <summary>
+        /// The combination of the path and query parameters for the current URL.
+        /// Only use this property if the language you are generating for doesn't support fluent API style (e.g. Shell/CLI)
+        /// </summary>
+        public IEnumerable<CodeParameter> PathAndQueryParameters { get; private set; }
+        public void AddPathOrQueryParameter(params CodeParameter[] parameters) {
+            if(parameters == null || !parameters.Any()) return;
+            foreach (var parameter in parameters) {
+                EnsureElementsAreChildren(parameter);
+            }
+            if(PathAndQueryParameters == null)
+                PathAndQueryParameters = new List<CodeParameter>(parameters);
+            else if (PathAndQueryParameters is List<CodeParameter> cast)
+                cast.AddRange(parameters);
+        }
         public bool IsOfKind(params CodeMethodKind[] kinds) {
             return kinds?.Contains(MethodKind) ?? false;
         }

src/Kiota.Builder/Extensions/OpenApiUrlTreeNodeExtensions.cs

@@ -115,8 +115,12 @@ private static string SanitizePathParameterNames(string original) {
             if(string.IsNullOrEmpty(original) || !original.Contains('{')) return original;
             var parameters = pathParamMatcher.Matches(original);
             foreach(var value in parameters.Select(x => x.Value))
-                original = original.Replace(value, value.Replace('-', '_'));
+                original = original.SanitizePathParameterName();
             return original;
         }
+        public static string SanitizePathParameterName(this string original) {
+            if(string.IsNullOrEmpty(original)) return original;
+            return original.Replace('-', '_');
+        }
     }
 }

src/Kiota.Builder/Extensions/StringExtensions.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
@@ -26,7 +26,7 @@ public static string ReplaceValueIdentifier(this string original) =>
         public static string TrimQuotes(this string original) =>
             original?.Trim('\'', '"');
 
-        public static string ToSnakeCase(this string name)
+        public static string ToSnakeCase(this string name, char separator = '_')
         {
             if(string.IsNullOrEmpty(name)) return name;
             var chunks = name.Split('-', StringSplitOptions.RemoveEmptyEntries);
@@ -40,7 +40,7 @@ public static string ToSnakeCase(this string name)
             foreach (var item in identifier[1..])
             {
                 if(char.IsUpper(item)) {
-                    sb.Append('_');
+                    sb.Append(separator);
                     sb.Append(char.ToLowerInvariant(item));
                 } else {
                     sb.Append(item);

src/Kiota.Builder/GenerationLanguage.cs

@@ -1,4 +1,4 @@
-namespace Kiota.Builder {
+namespace Kiota.Builder {
     public enum GenerationLanguage {
         CSharp,
         Java,
@@ -7,5 +7,6 @@ public enum GenerationLanguage {
         Python,
         Go,
         Ruby,
+        Shell
     }
 }

src/Kiota.Builder/KiotaBuilder.cs

@@ -586,10 +586,37 @@ private void CreateOperationMethods(OpenApiUrlTreeNode currentNode, OperationTyp
                 Description = operation.Description ?? operation.Summary,
                 ReturnType = new CodeType { Name = "RequestInformation", IsNullable = false, IsExternal = true},
             };
+            if(config.Language == GenerationLanguage.Shell)
+                SetPathAndQueryParameters(generatorMethod, currentNode, operation);
             parentClass.AddMethod(generatorMethod);
             AddRequestBuilderMethodParameters(currentNode, operation, parameterClass, generatorMethod);
             logger.LogTrace("Creating method {name} of {type}", generatorMethod.Name, generatorMethod.ReturnType);
         }
+        private static void SetPathAndQueryParameters(CodeMethod target, OpenApiUrlTreeNode currentNode, OpenApiOperation operation) {
+            var pathAndQueryParameters = currentNode
+                .PathItems[Constants.DefaultOpenApiLabel]
+                .Parameters
+                .Where(x => x.In == ParameterLocation.Path || x.In == ParameterLocation.Query)
+                .Select(x => new CodeParameter{
+                    Name = x.Name.TrimStart('$').SanitizePathParameterName(),
+                    Type = GetPrimitiveType(x.Schema),
+                    Description = x.Description,
+                    ParameterKind = x.In == ParameterLocation.Path ? CodeParameterKind.Path : CodeParameterKind.QueryParameter,
+                    Optional = !x.Required
+                })
+                .Union(operation
+                        .Parameters
+                        .Where(x => x.In == ParameterLocation.Path || x.In == ParameterLocation.Query)
+                        .Select(x => new CodeParameter{
+                                Name = x.Name.TrimStart('$').SanitizePathParameterName(),
+                                Type = GetPrimitiveType(x.Schema),
+                                Description = x.Description,
+                                ParameterKind = x.In == ParameterLocation.Path ? CodeParameterKind.Path : CodeParameterKind.QueryParameter,
+                                Optional = !x.Required
+                        }))
+                .ToArray();
+            target.AddPathOrQueryParameter(pathAndQueryParameters);
+        }
         private void AddRequestBuilderMethodParameters(OpenApiUrlTreeNode currentNode, OpenApiOperation operation, CodeClass parameterClass, CodeMethod method) {
             var nonBinaryRequestBody = operation.RequestBody?.Content?.FirstOrDefault(x => !RequestBodyBinaryContentType.Equals(x.Key, StringComparison.OrdinalIgnoreCase));
             if (nonBinaryRequestBody.HasValue && nonBinaryRequestBody.Value.Value != null)

src/Kiota.Builder/Refiners/ILanguageRefiner.cs

@@ -1,4 +1,4 @@
-namespace Kiota.Builder.Refiners
+namespace Kiota.Builder.Refiners
 {
     public interface ILanguageRefiner
     {
@@ -21,6 +21,9 @@ public static void Refine(GenerationConfiguration config, CodeNamespace generate
                 case GenerationLanguage.Go:
                     new GoRefiner(config).Refine(generatedCode);
                     break;
+                case GenerationLanguage.Shell:
+                    new ShellRefiner(config).Refine(generatedCode);
+                    break;
                 default:
                     break; //Do nothing
             }

src/Kiota.Builder/Refiners/ShellRefiner.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Kiota.Builder.Extensions;
+
+namespace Kiota.Builder.Refiners
+{
+    public class ShellRefiner : CommonLanguageRefiner, ILanguageRefiner
+    {
+        public ShellRefiner(GenerationConfiguration configuration) : base(configuration) { }
+        public override void Refine(CodeNamespace generatedCode)
+        {
+            // Remove PathSegment field
+            // Convert Properties to AddCommand
+
+
+            AddDefaultImports(generatedCode);
+            MoveClassesWithNamespaceNamesUnderNamespace(generatedCode);
+            ConvertUnionTypesToWrapper(generatedCode, _configuration.UsesBackingStore);
+            AddPropertiesAndMethodTypesImports(generatedCode, false, false, false);
+            //RemoveModelClasses(generatedCode);
+            //RemoveEnums(generatedCode);
+            //RemoveConstructors(generatedCode);
+            CreateCommandBuilders(generatedCode);
+            AddAsyncSuffix(generatedCode);
+            AddInnerClasses(generatedCode, false);
+            CapitalizeNamespacesFirstLetters(generatedCode);
+            ReplaceBinaryByNativeType(generatedCode, "Stream", "System.IO");
+            MakeEnumPropertiesNullable(generatedCode);
+            ReplaceReservedNames(generatedCode, new CSharpReservedNamesProvider(), x => $"@{x.ToFirstCharacterUpperCase()}");
+            DisambiguatePropertiesWithClassNames(generatedCode);
+            AddConstructorsForDefaultValues(generatedCode, false);
+            AddSerializationModulesImport(generatedCode);
+        }
+        private static void DisambiguatePropertiesWithClassNames(CodeElement currentElement)
+        {
+            if (currentElement is CodeClass currentClass)
+            {
+                var sameNameProperty = currentClass
+                                                .GetChildElements(true)
+                                                .OfType<CodeProperty>()
+                                                .FirstOrDefault(x => x.Name.Equals(currentClass.Name, StringComparison.OrdinalIgnoreCase));
+                if (sameNameProperty != null)
+                {
+                    currentClass.RemoveChildElement(sameNameProperty);
+                    sameNameProperty.SerializationName ??= sameNameProperty.Name;
+                    sameNameProperty.Name = $"{sameNameProperty.Name}_prop";
+                    currentClass.AddProperty(sameNameProperty);
+                }
+            }
+            CrawlTree(currentElement, DisambiguatePropertiesWithClassNames);
+        }
+        private static void MakeEnumPropertiesNullable(CodeElement currentElement)
+        {
+            if (currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.Model))
+                currentClass.GetChildElements(true)
+                            .OfType<CodeProperty>()
+                            .Where(x => x.Type is CodeType propType && propType.TypeDefinition is CodeEnum)
+                            .ToList()
+                            .ForEach(x => x.Type.IsNullable = true);
+            CrawlTree(currentElement, MakeEnumPropertiesNullable);
+        }
+        private static void RemoveModelClasses(CodeElement currentElement)
+        {
+            if (currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.Model))
+            {
+                var codeNamespace = currentClass.Parent as CodeNamespace;
+                codeNamespace.RemoveChildElement(currentClass);
+            }
+            CrawlTree(currentElement, RemoveModelClasses);
+        }
+
+        private static void RemoveEnums(CodeElement currentElement)
+        {
+            if (currentElement is CodeEnum currentEnum)
+            {
+                var codeNamespace = currentElement.Parent as CodeNamespace;
+                codeNamespace.RemoveChildElement(currentEnum);
+            }
+            CrawlTree(currentElement, RemoveEnums);
+        }
+
+        private static void RemoveConstructors(CodeElement currentElement)
+        {
+            if (currentElement is CodeMethod currentMethod && currentMethod.IsOfKind(CodeMethodKind.Constructor))
+            {
+                var codeClass = currentElement.Parent as CodeClass;
+                codeClass.RemoveChildElement(currentMethod);
+            }
+            CrawlTree(currentElement, RemoveConstructors);
+        }
+
+        private static void CreateCommandBuilders(CodeElement currentElement)
+        {
+            if (currentElement is CodeClass currentClass && currentClass.IsOfKind(CodeClassKind.RequestBuilder))
+            {
+                // Replace Nav Properties with BuildXXXCommand methods
+                var navProperties = currentClass.GetChildElements().OfType<CodeProperty>().Where(e => e.IsOfKind(CodePropertyKind.RequestBuilder));
+                foreach (var navProp in navProperties)
+                {
+                    var method = CreateBuildCommandMethod(navProp, currentClass);
+                    currentClass.AddMethod(method);
+                    currentClass.RemoveChildElement(navProp);
+                }
+                // Clone executors & convert to build command
+                var requestMethods = currentClass.GetChildElements().OfType<CodeMethod>().Where(e => e.IsOfKind(CodeMethodKind.RequestExecutor));
+                foreach (var requestMethod in requestMethods)
+                {
+                    CodeMethod clone = requestMethod.Clone() as CodeMethod;
+                    clone.IsAsync = false;
+                    clone.Name = $"Build{clone.Name}Command";
+                    clone.ReturnType = CreateCommandType(clone);
+                    clone.MethodKind = CodeMethodKind.CommandBuilder;
+                    clone.OriginalMethod = requestMethod;
+                    clone.ClearParameters();
+                    currentClass.AddMethod(clone);
+                }
+
+                var buildMethod = new CodeMethod
+                {
+                    Name = "Build",
+                    IsAsync = false,
+                    MethodKind = CodeMethodKind.CommandBuilder
+                };
+                buildMethod.AddParameter(new CodeParameter { Name = "httpCore", Type = new CodeType { Name = "IHttpCore", IsExternal = true } });
+                // Add calls to BuildMethods here..
+                buildMethod.ReturnType = new CodeType
+                {
+                    Name = "Command",
+                    IsExternal = true
+                };
+                currentClass.AddMethod(buildMethod);
+
+            }
+            CrawlTree(currentElement, CreateCommandBuilders);
+        }
+
+        private static CodeType CreateCommandType(CodeElement parent)
+        {
+            return new CodeType
+            {
+                Name = "Command",
+                IsExternal = true
+            };
+        }
+
+        private static CodeMethod CreateBuildCommandMethod(CodeProperty navProperty, CodeClass parent)
+        {
+            var codeMethod = new CodeMethod();
+            codeMethod.IsAsync = false;
+            codeMethod.IsStatic = true;
+            codeMethod.Name = $"Build{navProperty.Name.ToFirstCharacterUpperCase()}Command";
+            codeMethod.MethodKind = CodeMethodKind.CommandBuilder;
+            codeMethod.ReturnType = CreateCommandType(codeMethod);
+            return codeMethod;
+        }
+
+        private static readonly string[] defaultNamespacesForClasses = new string[] { "System", "System.Collections.Generic", "System.Linq" };
+        private static readonly string[] defaultNamespacesForRequestBuilders = new string[] { "System.Threading.Tasks", "System.IO", "Microsoft.Kiota.Abstractions", "Microsoft.Kiota.Abstractions.Serialization", "System.CommandLine", "System.CommandLine.Invocation" };
+
+        private static void AddDefaultImports(CodeElement current)
+        {
+            if (current is CodeClass currentClass)
+            {
+                currentClass.AddUsing(defaultNamespacesForClasses.Select(x => new CodeUsing { Name = x }).ToArray());
+                if (currentClass.IsOfKind(CodeClassKind.RequestBuilder))
+                    currentClass.AddUsing(defaultNamespacesForRequestBuilders.Select(x => new CodeUsing { Name = x }).ToArray());
+            }
+            CrawlTree(current, AddDefaultImports);
+        }
+        private static void CapitalizeNamespacesFirstLetters(CodeElement current)
+        {
+            if (current is CodeNamespace currentNamespace)
+                currentNamespace.Name = currentNamespace.Name?.Split('.')?.Select(x => x.ToFirstCharacterUpperCase())?.Aggregate((x, y) => $"{x}.{y}");
+            CrawlTree(current, CapitalizeNamespacesFirstLetters);
+        }
+        private static void AddAsyncSuffix(CodeElement currentElement)
+        {
+            if (currentElement is CodeMethod currentMethod && currentMethod.IsAsync)
+                currentMethod.Name += "Async";
+            CrawlTree(currentElement, AddAsyncSuffix);
+        }
+    }
+}

src/Kiota.Builder/Writers/CSharp/CSharpWriter.cs

@@ -6,13 +6,13 @@ public CSharpWriter(string rootPath, string clientNamespaceName)
         {
             PathSegmenter = new CSharpPathSegmenter(rootPath, clientNamespaceName);
             var conventionService = new CSharpConventionService();
-            AddCodeElementWriter(new CodeClassDeclarationWriter(conventionService));
-            AddCodeElementWriter(new CodeClassEndWriter(conventionService));
-            AddCodeElementWriter(new CodeEnumWriter(conventionService));
-            AddCodeElementWriter(new CodeIndexerWriter(conventionService));
-            AddCodeElementWriter(new CodeMethodWriter(conventionService));
-            AddCodeElementWriter(new CodePropertyWriter(conventionService));
-            AddCodeElementWriter(new CodeTypeWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeClassDeclarationWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeClassEndWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeEnumWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeIndexerWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeMethodWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodePropertyWriter(conventionService));
+            AddOrReplaceCodeElementWriter(new CodeTypeWriter(conventionService));
 
         }
     }