refactor --check-type and --package-path and service initialization for language repos

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Services/Languages/GoLanguageRepoServiceTests.cs → tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Services/Languages/GoLanguageSpecificChecksTests.cs

@@ -8,12 +8,12 @@
 
 namespace Azure.Sdk.Tools.Cli.Tests.Services
 {
-    internal class GoLanguageRepoServiceTests
+    internal class GoLanguageSpecificChecksTests
     {
         private string GoPackageDir { get; set; }
         private static string GoProgram => RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "go.exe" : "go";
 
-        private GoLanguageRepoService LangService { get; set; }
+        private GoLanguageSpecificChecks LangService { get; set; }
 
         [SetUp]
         public async Task SetUp()
@@ -23,11 +23,11 @@ public async Task SetUp()
 
             var mockGitHubService = new Mock<IGitHubService>();
             var gitHelper = new GitHelper(mockGitHubService.Object, NullLogger<GitHelper>.Instance);
-            LangService = new GoLanguageRepoService(new ProcessHelper(NullLogger<ProcessHelper>.Instance, Mock.Of<IOutputHelper>()), new NpxHelper(NullLogger<NpxHelper>.Instance, Mock.Of<IOutputHelper>()), gitHelper, NullLogger<GoLanguageRepoService>.Instance);
+            LangService = new GoLanguageSpecificChecks(new ProcessHelper(NullLogger<ProcessHelper>.Instance, Mock.Of<IOutputHelper>()), new NpxHelper(NullLogger<NpxHelper>.Instance, Mock.Of<IOutputHelper>()), gitHelper, NullLogger<GoLanguageSpecificChecks>.Instance);
 
             if (!await LangService.CheckDependencies(CancellationToken.None))
             {
-                Assert.Ignore("go and golangci-lint aren't installed, can't run GoLanguageRepoServiceTests");
+                Assert.Ignore("go and golangci-lint aren't installed, can't run GoLanguageSpecificChecksTests");
             }
 
             var resp = await LangService.CreateEmptyPackage(GoPackageDir, "untitleddotloop", CancellationToken.None);
@@ -51,7 +51,7 @@ public void TearDown()
         }
 
         [Test]
-        public async Task TestGoLanguageRepoServiceBasic()
+        public async Task TestGoLanguageSpecificChecksBasic()
         {
             await File.WriteAllTextAsync(Path.Combine(GoPackageDir, "main.go"), """
                 package main
@@ -89,7 +89,7 @@ func main() {
         }
 
         [Test]
-        public async Task TestGoLanguageRepoServiceCompileErrors()
+        public async Task TestGoLanguageSpecificChecksCompileErrors()
         {
             await File.WriteAllTextAsync(Path.Combine(GoPackageDir, "main.go"), """
                 package main
@@ -111,7 +111,7 @@ syntax error
         }
 
         [Test]
-        public async Task TestGoLanguageRepoServiceLintErrors()
+        public async Task TestGoLanguageSpecificChecksLintErrors()
         {
             await File.WriteAllTextAsync(Path.Combine(GoPackageDir, "main.go"), """
                 package main

tools/azsdk-cli/Azure.Sdk.Tools.Cli.Tests/Tools/CheckAllToolTests.cs

@@ -12,7 +12,13 @@ public class PackageCheckToolTests
     {
         private Mock<ILogger<PackageCheckTool>> _mockLogger;
         private Mock<IOutputHelper> _mockOutputHelper;
-        private Mock<ILanguageRepoServiceFactory> _mockLanguageRepoServiceFactory;
+        private Mock<IProcessHelper> _mockProcessHelper;
+        private Mock<INpxHelper> _mockNpxHelper;
+        private Mock<IGitHelper> _mockGitHelper;
+        private Mock<ILogger<LanguageChecks>> _mockLanguageChecksLogger;
+        private Mock<ILogger<PythonLanguageSpecificChecks>> _mockPythonLogger;
+        private Mock<ILogger<LanguageSpecificCheckResolver>> _mockResolverLogger;
+        private LanguageChecks _languageChecks;
         private PackageCheckTool _packageCheckTool;
         private string _testProjectPath;
 
@@ -21,9 +27,27 @@ public void Setup()
         {
             _mockLogger = new Mock<ILogger<PackageCheckTool>>();
             _mockOutputHelper = new Mock<IOutputHelper>();
-            _mockLanguageRepoServiceFactory = new Mock<ILanguageRepoServiceFactory>();
-
-            _packageCheckTool = new PackageCheckTool(_mockLogger.Object, _mockOutputHelper.Object, _mockLanguageRepoServiceFactory.Object);
+            _mockProcessHelper = new Mock<IProcessHelper>();
+            _mockNpxHelper = new Mock<INpxHelper>();
+            _mockGitHelper = new Mock<IGitHelper>();
+            _mockLanguageChecksLogger = new Mock<ILogger<LanguageChecks>>();
+            _mockPythonLogger = new Mock<ILogger<PythonLanguageSpecificChecks>>();
+            _mockResolverLogger = new Mock<ILogger<LanguageSpecificCheckResolver>>();
+
+            // Create language-specific check implementations with mocked dependencies
+            var pythonCheck = new PythonLanguageSpecificChecks(_mockProcessHelper.Object, _mockNpxHelper.Object, _mockGitHelper.Object, _mockPythonLogger.Object);
+
+            var languageChecks = new List<ILanguageSpecificChecks> { pythonCheck };
+            var mockPowershellHelper = new Mock<IPowershellHelper>();
+            var resolver = new LanguageSpecificCheckResolver(languageChecks, _mockGitHelper.Object, mockPowershellHelper.Object, _mockResolverLogger.Object);            _languageChecks = new LanguageChecks(_mockProcessHelper.Object, _mockNpxHelper.Object, _mockGitHelper.Object, _mockLanguageChecksLogger.Object, resolver);
+            _packageCheckTool = new PackageCheckTool(_mockLogger.Object, _mockOutputHelper.Object, _languageChecks);
+
+            // Setup default mock responses
+            var defaultProcessResult = new ProcessResult { ExitCode = 0, OutputDetails = new List<(StdioLevel, string)>() };
+            _mockProcessHelper.Setup(x => x.Run(It.IsAny<ProcessOptions>(), It.IsAny<CancellationToken>()))
+                             .ReturnsAsync(defaultProcessResult);
+            _mockNpxHelper.Setup(x => x.Run(It.IsAny<NpxOptions>(), It.IsAny<CancellationToken>()))
+                         .ReturnsAsync(defaultProcessResult);
 
             // Create a temporary test directory
             _testProjectPath = Path.Combine(Path.GetTempPath(), "PackageCheckToolTest");

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Commands/SharedOptions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.IO.Enumeration;
@@ -63,9 +64,9 @@ public static class SharedOptions
             IsRequired = false,
         };
 
-        public static Option<string> PackagePath = new(["--package-path", "-p"], "Path to the package directory to check")
+        public static Option<string> PackagePath = new(["--package-path", "-p"], () => Environment.CurrentDirectory, "Path to the package directory to check. Defaults to the current working directory")
         {
-            IsRequired = true
+            IsRequired = false
         };
 
         public static (string, bool) GetGlobalOptionValues(string[] args)

tools/azsdk-cli/Azure.Sdk.Tools.Cli/Models/Responses/CLICheckResponse.cs

@@ -1,4 +1,5 @@
 using System.Text.Json.Serialization;
+using Azure.Sdk.Tools.Cli.Helpers;
 
 namespace Azure.Sdk.Tools.Cli.Models;
 
@@ -25,6 +26,16 @@ public CLICheckResponse(int exitCode, string checkStatusDetails, string error =
         }
     }
 
+    /// <summary>
+    /// Creates a CLICheckResponse from a process result.
+    /// </summary>
+    /// <param name="processResult">The process result to convert</param>
+    /// <returns>CLI check response</returns>
+    public static CLICheckResponse CreateResponseFromProcessResult(ProcessResult processResult)
+    {
+        return new CLICheckResponse(processResult.ExitCode, processResult.Output);
+    }
+
     public override string ToString()
     {
         return ToString(CheckStatusDetails);

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

@@ -0,0 +1,38 @@
+using System.Runtime.InteropServices;
+using Azure.Sdk.Tools.Cli.Models;
+using Azure.Sdk.Tools.Cli.Helpers;
+using Microsoft.Extensions.Logging;
+
+namespace Azure.Sdk.Tools.Cli.Services;
+
+/// <summary>
+/// .NET-specific implementation of language repository service.
+/// Uses tools like dotnet CLI, MSBuild, NuGet, etc. for .NET development workflows.
+/// </summary>
+public class DotNetLanguageSpecificChecks : ILanguageSpecificChecks
+{
+    private readonly IProcessHelper _processHelper;
+    private readonly INpxHelper _npxHelper;
+    private readonly IGitHelper _gitHelper;
+    private readonly ILogger<DotNetLanguageSpecificChecks> _logger;
+
+    public DotNetLanguageSpecificChecks(
+        IProcessHelper processHelper,
+        INpxHelper npxHelper,
+        IGitHelper gitHelper,
+        ILogger<DotNetLanguageSpecificChecks> logger)
+    {
+        _processHelper = processHelper;
+        _npxHelper = npxHelper;
+        _gitHelper = gitHelper;
+        _logger = logger;
+    }
+
+    public string SupportedLanguage => "dotnet";
+
+    public async Task<CLICheckResponse> AnalyzeDependenciesAsync(string packagePath, CancellationToken ct)
+    {
+        // Implementation for analyzing dependencies in a .NET project
+        return await Task.FromResult(new CLICheckResponse());
+    }
+}