Rename CLICheckResponse as PackageCheckResponse (#12733)

Author: praveenkuttappan

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Models/Responses/Package/CLICheckResponse.cs renamed to tools/azsdk-cli/Azure.Sdk.Tools.Cli/Models/Responses/Package/PackageCheckResponse.cs

@@ -7,7 +7,7 @@ namespace Azure.Sdk.Tools.Cli.Models.Responses.Package;
 /// <summary>
 /// Base class for CLI check responses with exit code and output.
 /// </summary>
-public class CLICheckResponse : PackageResponseBase
+public class PackageCheckResponse : PackageResponseBase
 {
     // Map ExitCode to CliExitCode for JSON serialization
     [JsonPropertyName("exit_code")]
@@ -16,9 +16,9 @@ public class CLICheckResponse : PackageResponseBase
     [JsonPropertyName("check_status_details")]
     public string CheckStatusDetails { get; set; }
 
-    public CLICheckResponse() { }
+    public PackageCheckResponse() { }
 
-    public CLICheckResponse(int exitCode, string checkStatusDetails, string error = null)
+    public PackageCheckResponse(int exitCode, string checkStatusDetails, string error = null)
     {
         ExitCode = exitCode;
         CheckStatusDetails = checkStatusDetails;
@@ -28,7 +28,7 @@ public CLICheckResponse(int exitCode, string checkStatusDetails, string error =
         }
     }
 
-    public CLICheckResponse(ProcessResult processResult)
+    public PackageCheckResponse(ProcessResult processResult)
     {
         ExitCode = processResult.ExitCode;
         CheckStatusDetails = processResult.Output;
@@ -45,14 +45,14 @@ protected override string Format()
 }
 
 /// <summary>
-/// CLI check response for cookbook/documentation reference responses.
+/// Package check response for cookbook/documentation reference responses.
 /// </summary>
-public class CookbookCLICheckResponse : CLICheckResponse
+public class CookbookPackageCheckResponse : PackageCheckResponse
 {
     [JsonPropertyName("cookbook_reference")]
     public string CookbookReference { get; set; }
 
-    public CookbookCLICheckResponse(int exitCode, string checkStatusDetails, string cookbookReference) : base(exitCode, checkStatusDetails)
+    public CookbookPackageCheckResponse(int exitCode, string checkStatusDetails, string cookbookReference) : base(exitCode, checkStatusDetails)
     {
         CookbookReference = cookbookReference;
     }

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Services/Languages/DotNetLanguageSpecificChecks.cs

@@ -31,7 +31,7 @@ public DotNetLanguageSpecificChecks(
         _logger = logger;
     }
 
-    public async Task<CLICheckResponse> CheckGeneratedCode(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
+    public async Task<PackageCheckResponse> CheckGeneratedCode(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
     {
         try
         {
@@ -48,15 +48,15 @@ public async Task<CLICheckResponse> CheckGeneratedCode(string packagePath, bool
             if (serviceDirectory == null)
             {
                 _logger.LogError("Failed to determine service directory from package path: {PackagePath}", packagePath);
-                return new CLICheckResponse(1, "", "Failed to determine service directory from the provided package path.");
+                return new PackageCheckResponse(1, "", "Failed to determine service directory from the provided package path.");
             }
 
             var repoRoot = _gitHelper.DiscoverRepoRoot(packagePath);
             var scriptPath = Path.Combine(repoRoot, "eng", "scripts", "CodeChecks.ps1");
             if (!File.Exists(scriptPath))
             {
                 _logger.LogError("Code checks script not found at: {ScriptPath}", scriptPath);
-                return new CLICheckResponse(1, "", $"Code checks script not found at: {scriptPath}");
+                return new PackageCheckResponse(1, "", $"Code checks script not found at: {scriptPath}");
             }
 
             var args = new[] { scriptPath, "-ServiceDirectory", serviceDirectory, "-SpellCheckPublicApiSurface" };
@@ -66,22 +66,22 @@ public async Task<CLICheckResponse> CheckGeneratedCode(string packagePath, bool
             if (result.ExitCode == 0)
             {
                 _logger.LogInformation("Generated code checks completed successfully");
-                return new CLICheckResponse(result.ExitCode, result.Output);
+                return new PackageCheckResponse(result.ExitCode, result.Output);
             }
             else
             {
                 _logger.LogWarning("Generated code checks for package at {PackagePath} failed with exit code {ExitCode}", packagePath, result.ExitCode);
-                return new CLICheckResponse(result.ExitCode, result.Output, "Generated code checks failed");
+                return new PackageCheckResponse(result.ExitCode, result.Output, "Generated code checks failed");
             }
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Error running generated code checks at {PackagePath}", packagePath);
-            return new CLICheckResponse(1, "", $"Error running generated code checks: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"Error running generated code checks: {ex.Message}");
         }
     }
 
-    public async Task<CLICheckResponse> CheckAotCompat(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
+    public async Task<PackageCheckResponse> CheckAotCompat(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
     {
         try
         {
@@ -99,22 +99,22 @@ public async Task<CLICheckResponse> CheckAotCompat(string packagePath, bool fixC
             if (serviceDirectory == null || packageName == null)
             {
                 _logger.LogError("Failed to determine service directory or package name from package path: {PackagePath}", packagePath);
-                return new CLICheckResponse(1, "", "Failed to determine service directory or package name from the provided package path.");
+                return new PackageCheckResponse(1, "", "Failed to determine service directory or package name from the provided package path.");
             }
 
             var isAotOptedOut = await CheckAotCompatOptOut(packagePath, packageName, ct);
             if (isAotOptedOut)
             {
                 _logger.LogInformation("AOT compatibility check skipped - AotCompatOptOut is set to true in project file");
-                return new CLICheckResponse(0, "AOT compatibility check skipped - AotCompatOptOut is set to true in project file");
+                return new PackageCheckResponse(0, "AOT compatibility check skipped - AotCompatOptOut is set to true in project file");
             }
 
             var repoRoot = _gitHelper.DiscoverRepoRoot(packagePath);
             var scriptPath = Path.Combine(repoRoot, "eng", "scripts", "compatibility", "Check-AOT-Compatibility.ps1");
             if (!File.Exists(scriptPath))
             {
                 _logger.LogError("AOT compatibility script not found at: {ScriptPath}", scriptPath);
-                return new CLICheckResponse(1, "", $"AOT compatibility script not found at: {scriptPath}");
+                return new PackageCheckResponse(1, "", $"AOT compatibility script not found at: {scriptPath}");
             }
 
             var workingDirectory = Path.Combine(repoRoot, "eng", "scripts", "compatibility");
@@ -126,28 +126,28 @@ public async Task<CLICheckResponse> CheckAotCompat(string packagePath, bool fixC
             if (result.ExitCode == 0)
             {
                 _logger.LogInformation("AOT compatibility check completed successfully");
-                return new CLICheckResponse(result.ExitCode, result.Output);
+                return new PackageCheckResponse(result.ExitCode, result.Output);
             }
             else
             {
                 _logger.LogWarning("AOT compatibility check failed with exit code {ExitCode}", result.ExitCode);
-                return new CLICheckResponse(result.ExitCode, result.Output, "AOT compatibility check failed");
+                return new PackageCheckResponse(result.ExitCode, result.Output, "AOT compatibility check failed");
             }
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "Error running AOT compatibility check at {PackagePath}", packagePath);
-            return new CLICheckResponse(1, "", $"Error running AOT compatibility check: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"Error running AOT compatibility check: {ex.Message}");
         }
     }
 
-    private async ValueTask<CLICheckResponse> VerifyDotnetVersion()
+    private async ValueTask<PackageCheckResponse> VerifyDotnetVersion()
     {
         var dotnetSDKCheck = await _processHelper.Run(new ProcessOptions(DotNetCommand, ["--list-sdks"]), CancellationToken.None);
         if (dotnetSDKCheck.ExitCode != 0)
         {
             _logger.LogError(".NET SDK is not installed or not available in PATH");
-            return new CLICheckResponse(dotnetSDKCheck.ExitCode, $"dotnet --list-sdks failed with an error: {dotnetSDKCheck.Output}");
+            return new PackageCheckResponse(dotnetSDKCheck.ExitCode, $"dotnet --list-sdks failed with an error: {dotnetSDKCheck.Output}");
         }
 
         var dotnetVersions = dotnetSDKCheck.Output.Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
@@ -159,18 +159,18 @@ private async ValueTask<CLICheckResponse> VerifyDotnetVersion()
             if (installedVersion >= minimumVersion)
             {
                 _logger.LogInformation(".NET SDK version {InstalledVersion} meets minimum requirement of {RequiredVersion}", latestVersionNumber, RequiredDotNetVersion);
-                return new CLICheckResponse(0, $".NET SDK version {latestVersionNumber} meets minimum requirement of {RequiredDotNetVersion}");
+                return new PackageCheckResponse(0, $".NET SDK version {latestVersionNumber} meets minimum requirement of {RequiredDotNetVersion}");
             }
             else
             {
                 _logger.LogError(".NET SDK version {InstalledVersion} is below minimum requirement of {RequiredVersion}", latestVersionNumber, RequiredDotNetVersion);
-                return new CLICheckResponse(1, "", $".NET SDK version {latestVersionNumber} is below minimum requirement of {RequiredDotNetVersion}");
+                return new PackageCheckResponse(1, "", $".NET SDK version {latestVersionNumber} is below minimum requirement of {RequiredDotNetVersion}");
             }
         }
         else
         {
             _logger.LogError("Failed to parse .NET SDK version: {VersionString}", latestVersionNumber);
-            return new CLICheckResponse(1, "", $"Failed to parse .NET SDK version: {latestVersionNumber}");
+            return new PackageCheckResponse(1, "", $"Failed to parse .NET SDK version: {latestVersionNumber}");
         }
     }
 

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Services/Languages/GoLanguageSpecificChecks.cs

@@ -53,44 +53,44 @@ public async Task<bool> CheckDependencies(CancellationToken ct)
         }
     }
 
-    public async Task<CLICheckResponse> CreateEmptyPackage(string packagePath, string moduleName, CancellationToken ct)
+    public async Task<PackageCheckResponse> CreateEmptyPackage(string packagePath, string moduleName, CancellationToken ct)
     {
         try
         {
             var result = await _processHelper.Run(new ProcessOptions(compilerName, ["mod", "init", moduleName], compilerNameWindows, ["mod", "init", moduleName], workingDirectory: packagePath), ct);
-            return new CLICheckResponse(result);
+            return new PackageCheckResponse(result);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(CreateEmptyPackage));
-            return new CLICheckResponse(1, "", $"{nameof(CreateEmptyPackage)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(CreateEmptyPackage)} failed with an exception: {ex.Message}");
         }
     }
 
     #endregion
 
-    public async Task<CLICheckResponse> AnalyzeDependenciesAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
+    public async Task<PackageCheckResponse> AnalyzeDependenciesAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
     {
         try
         {
             // Update all dependencies to the latest first
             var updateResult = await _processHelper.Run(new ProcessOptions(compilerName, ["get", "-u", "all"], compilerNameWindows, ["get", "-u", "all"], workingDirectory: packagePath), ct);
             if (updateResult.ExitCode != 0)
             {
-                return new CLICheckResponse(updateResult);
+                return new PackageCheckResponse(updateResult);
             }
 
             // Now tidy, to cleanup any deps that aren't needed
             var tidyResult = await _processHelper.Run(new ProcessOptions(compilerName, ["mod", "tidy"], compilerNameWindows, ["mod", "tidy"], workingDirectory: packagePath), ct);
-            return new CLICheckResponse(tidyResult);
+            return new PackageCheckResponse(tidyResult);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(AnalyzeDependenciesAsync));
-            return new CLICheckResponse(1, "", $"{nameof(AnalyzeDependenciesAsync)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(AnalyzeDependenciesAsync)} failed with an exception: {ex.Message}");
         }
     }
-    public async Task<CLICheckResponse> FormatCodeAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
+    public async Task<PackageCheckResponse> FormatCodeAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
     {
         try
         {
@@ -99,54 +99,54 @@ public async Task<CLICheckResponse> FormatCodeAsync(string packagePath, bool fix
                 formatterNameWindows, ["-w", "."],
                 workingDirectory: packagePath
             ), ct);
-            return new CLICheckResponse(result);
+            return new PackageCheckResponse(result);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(FormatCodeAsync));
-            return new CLICheckResponse(1, "", $"{nameof(FormatCodeAsync)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(FormatCodeAsync)} failed with an exception: {ex.Message}");
         }
     }
 
-    public async Task<CLICheckResponse> LintCodeAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
+    public async Task<PackageCheckResponse> LintCodeAsync(string packagePath, bool fixCheckErrors = false, CancellationToken ct = default)
     {
         try
         {
             var result = await _processHelper.Run(new ProcessOptions(linterName, ["run"], linterNameWindows, ["run"], workingDirectory: packagePath), ct);
-            return new CLICheckResponse(result);
+            return new PackageCheckResponse(result);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(LintCodeAsync));
-            return new CLICheckResponse(1, "", $"{nameof(LintCodeAsync)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(LintCodeAsync)} failed with an exception: {ex.Message}");
         }
     }
 
-    public async Task<CLICheckResponse> RunTestsAsync(string packagePath, CancellationToken ct)
+    public async Task<PackageCheckResponse> RunTestsAsync(string packagePath, CancellationToken ct)
     {
         try
         {
             var result = await _processHelper.Run(new ProcessOptions(compilerName, ["test", "-v", "-timeout", "1h", "./..."], compilerNameWindows, ["test", "-v", "-timeout", "1h", "./..."], workingDirectory: packagePath), ct);
-            return new CLICheckResponse(result);
+            return new PackageCheckResponse(result);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(RunTestsAsync));
-            return new CLICheckResponse(1, "", $"{nameof(RunTestsAsync)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(RunTestsAsync)} failed with an exception: {ex.Message}");
         }
     }
 
-    public async Task<CLICheckResponse> BuildProjectAsync(string packagePath, CancellationToken ct)
+    public async Task<PackageCheckResponse> BuildProjectAsync(string packagePath, CancellationToken ct)
     {
         try
         {
             var result = await _processHelper.Run(new ProcessOptions(compilerName, ["build"], compilerNameWindows, ["build"], workingDirectory: packagePath), ct);
-            return new CLICheckResponse(result);
+            return new PackageCheckResponse(result);
         }
         catch (Exception ex)
         {
             _logger.LogError(ex, "{MethodName} failed with an exception", nameof(BuildProjectAsync));
-            return new CLICheckResponse(1, "", $"{nameof(BuildProjectAsync)} failed with an exception: {ex.Message}");
+            return new PackageCheckResponse(1, "", $"{nameof(BuildProjectAsync)} failed with an exception: {ex.Message}");
         }
     }
 
@@ -163,8 +163,8 @@ public async Task<string> GetSDKPackageName(string repo, string packagePath, Can
         return await Task.FromResult(relativePath.Replace(Path.DirectorySeparatorChar, '/'));
     }
 
-    public async Task<CLICheckResponse> UpdateSnippetsAsync(string packagePath, bool fixCheckErrors = false, CancellationToken cancellationToken = default)
+    public async Task<PackageCheckResponse> UpdateSnippetsAsync(string packagePath, bool fixCheckErrors = false, CancellationToken cancellationToken = default)
     {
-        return await Task.FromResult(new CLICheckResponse());
+        return await Task.FromResult(new PackageCheckResponse());
     }
 }