Revert accidental removal of functional code in TestCommand and telem…

…etry files

Co-authored-by: baronfel <[email protected]>

src/Cli/dotnet/Commands/Test/VSTest/TestCommand.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.Versioning;
 using System.Text.RegularExpressions;
@@ -40,21 +41,41 @@ public static int Run(ParseResult parseResult)
             VSTestTrace.SafeWriteTrace(() => $"Argument list: '{commandLineParameters}'");
         }
 
-        // settings parameters are after -- (including --), these should not be considered by the parser
-        string[] settings = [.. args.SkipWhile(a => a != "--")];
-        // all parameters before --
-        args = [.. args.TakeWhile(a => a != "--")];
+        (args, string[] settings) = SeparateSettingsFromArgs(args);
 
         // Fix for https://github.com/Microsoft/vstest/issues/1453
         // Run dll/exe directly using the VSTestForwardingApp
-        if (ContainsBuiltTestSources(args))
+        // Note: ContainsBuiltTestSources need to know how many settings are there, to skip those from unmatched tokens
+        // When we don't have settings, we pass 0.
+        // When we have settings, we want to exclude the '--' as it doesn't end up in unmatched tokens, so we pass settings.Length - 1
+        if (ContainsBuiltTestSources(parseResult, GetSettingsCount(settings)))
         {
             return ForwardToVSTestConsole(parseResult, args, settings, testSessionCorrelationId);
         }
 
         return ForwardToMsbuild(parseResult, settings, testSessionCorrelationId);
     }
 
+    internal /*internal for testing*/ static (string[] Args, string[] Settings) SeparateSettingsFromArgs(string[] args)
+    {
+        // settings parameters are after -- (including --), these should not be considered by the parser
+        string[] settings = [.. args.SkipWhile(a => a != "--")];
+        // all parameters before --
+        args = [.. args.TakeWhile(a => a != "--")];
+        return (args, settings);
+    }
+
+    internal /*internal for testing*/ static int GetSettingsCount(string[] settings)
+    {
+        if (settings.Length == 0)
+        {
+            return 0;
+        }
+
+        Debug.Assert(settings[0] == "--", "Settings should start with --");
+        return settings.Length - 1;
+    }
+
     private static int ForwardToMsbuild(ParseResult parseResult, string[] settings, string testSessionCorrelationId)
     {
         // Workaround for https://github.com/Microsoft/vstest/issues/1503
@@ -154,7 +175,7 @@ private static int ForwardToVSTestConsole(ParseResult parseResult, string[] args
 
     public static TestCommand FromArgs(string[] args, string? testSessionCorrelationId = null, string? msbuildPath = null)
     {
-        var parseResult = Parser.Parse(["dotnet", "test", ..args]);
+        var parseResult = Parser.Parse(["dotnet", "test", .. args]);
 
         // settings parameters are after -- (including --), these should not be considered by the parser
         string[] settings = [.. args.SkipWhile(a => a != "--")];
@@ -237,9 +258,10 @@ private static TestCommand FromParseResult(ParseResult result, string[] settings
             }
         }
 
-        
+
         Dictionary<string, string> variables = VSTestForwardingApp.GetVSTestRootVariables();
-        foreach (var (rootVariableName, rootValue) in variables) {
+        foreach (var (rootVariableName, rootValue) in variables)
+        {
             testCommand.EnvironmentVariable(rootVariableName, rootValue);
             VSTestTrace.SafeWriteTrace(() => $"Root variable set {rootVariableName}:{rootValue}");
         }
@@ -293,18 +315,14 @@ internal static int RunArtifactPostProcessingIfNeeded(string testSessionCorrelat
         }
     }
 
-    private static bool ContainsBuiltTestSources(string[] args)
+    internal /*internal for testing*/ static bool ContainsBuiltTestSources(ParseResult parseResult, int settingsLength)
     {
-        for (int i = 0; i < args.Length; i++)
+        for (int i = 0; i < parseResult.UnmatchedTokens.Count - settingsLength; i++)
         {
-            string arg = args[i];
-            if (arg.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || arg.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+            string arg = parseResult.UnmatchedTokens[i];
+            if (!arg.StartsWith("-") &&
+                (arg.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) || arg.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)))
             {
-                var previousArg = i > 0 ? args[i - 1] : null;
-                if (previousArg != null &&  CommonOptions.PropertiesOption.Aliases.Contains(previousArg))
-                {
-                    return false;
-                }
                 return true;
             }
         }

src/Cli/dotnet/Telemetry/EnvironmentDetectionRule.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli.Telemetry;
 
@@ -33,8 +34,7 @@ public BooleanEnvironmentRule(params string[] variables)
 
     public override bool IsMatch()
     {
-        return _variables.Any(variable => 
-            bool.TryParse(Environment.GetEnvironmentVariable(variable), out bool value) && value);
+        return _variables.Any(variable => Env.GetEnvironmentVariableAsBool(variable));
     }
 }
 
@@ -81,12 +81,12 @@ public override bool IsMatch()
 /// <typeparam name="T">The type of the result value.</typeparam>
 internal class EnvironmentDetectionRuleWithResult<T> where T : class
 {
-    private readonly string[] _variables;
+    private readonly EnvironmentDetectionRule _rule;
     private readonly T _result;
 
-    public EnvironmentDetectionRuleWithResult(T result, params string[] variables)
+    public EnvironmentDetectionRuleWithResult(T result, EnvironmentDetectionRule rule)
     {
-        _variables = variables ?? throw new ArgumentNullException(nameof(variables));
+        _rule = rule ?? throw new ArgumentNullException(nameof(rule));
         _result = result ?? throw new ArgumentNullException(nameof(result));
     }
 
@@ -96,8 +96,8 @@ public EnvironmentDetectionRuleWithResult(T result, params string[] variables)
     /// <returns>The result value if the rule matches; otherwise, null.</returns>
     public T? GetResult()
     {
-        return _variables.Any(variable => !string.IsNullOrEmpty(Environment.GetEnvironmentVariable(variable))) 
-            ? _result 
+        return _rule.IsMatch()
+            ? _result
             : null;
     }
-}
+}

src/Cli/dotnet/Telemetry/ILLMEnvironmentDetector.cs

@@ -5,5 +5,13 @@ namespace Microsoft.DotNet.Cli.Telemetry;
 
 internal interface ILLMEnvironmentDetector
 {
+    /// <summary>
+    /// Checks the current environment for known indicators of LLM usage and returns a string identifying the LLM environment if detected.
+    /// </summary>
     string? GetLLMEnvironment();
-}
+
+    /// <summary>
+    /// Returns true if the current environment is detected to be an LLM/agentic environment, false otherwise.
+    /// </summary>
+    bool IsLLMEnvironment();
+}

src/Cli/dotnet/Telemetry/LLMEnvironmentDetectorForTelemetry.cs

@@ -1,23 +1,30 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System;
-using System.Linq;
-
 namespace Microsoft.DotNet.Cli.Telemetry;
 
 internal class LLMEnvironmentDetectorForTelemetry : ILLMEnvironmentDetector
 {
     private static readonly EnvironmentDetectionRuleWithResult<string>[] _detectionRules = [
         // Claude Code
-        new EnvironmentDetectionRuleWithResult<string>("claude", "CLAUDECODE"),
+        new EnvironmentDetectionRuleWithResult<string>("claude", new AnyPresentEnvironmentRule("CLAUDECODE")),
         // Cursor AI
-        new EnvironmentDetectionRuleWithResult<string>("cursor", "CURSOR_EDITOR")
+        new EnvironmentDetectionRuleWithResult<string>("cursor", new AnyPresentEnvironmentRule("CURSOR_EDITOR")),
+        // Gemini
+        new EnvironmentDetectionRuleWithResult<string>("gemini", new BooleanEnvironmentRule("GEMINI_CLI")),
+        // GitHub Copilot
+        new EnvironmentDetectionRuleWithResult<string>("copilot", new BooleanEnvironmentRule("GITHUB_COPILOT_CLI_MODE")),
+        // (proposed) generic flag for Agentic usage
+        new EnvironmentDetectionRuleWithResult<string>("generic_agent", new BooleanEnvironmentRule("AGENT_CLI")),
     ];
 
+    /// <inheritdoc/>
     public string? GetLLMEnvironment()
     {
         var results = _detectionRules.Select(r => r.GetResult()).Where(r => r != null).ToArray();
         return results.Length > 0 ? string.Join(", ", results) : null;
     }
-}
+
+    /// <inheritdoc/>
+    public bool IsLLMEnvironment() => !string.IsNullOrEmpty(GetLLMEnvironment());
+}