• Add ILLMEnvironmentDetector interface following the CI detector pattern
• Add LLMEnvironmentDetectorForTelemetry implementation detecting CLAUDECODE environment variable
• Integrate LLM detection into TelemetryCommonProperties with "llm" property name
• Update implementation to return descriptive tool names ("claude") instead of boolean values
• Add comprehensive unit tests covering LLM detection scenarios
• Simplify test cases to only test essential scenarios (positive case and null case)
• Implement rule-based environment detection system
• Refactor CI detection to use rule-based approach
• Enable nullable reference types across all detection interfaces
• Add support for multiple LLM environment detection with comma-separated output

Implementation Details

Rule-Based Environment Detection System

Implemented an extensible rule-based system for environment detection that encapsulates matching logic in a single place:

// Abstract base class for environment detection rules
internal abstract class EnvironmentDetectionRule
{
    public abstract bool IsMatch();
}

// Specific rule implementations
internal class BooleanEnvironmentRule : EnvironmentDetectionRule          // For variables that parse as "true"
internal class AllPresentEnvironmentRule : EnvironmentDetectionRule      // All variables must be present
internal class AnyPresentEnvironmentRule : EnvironmentDetectionRule      // Any variable must be present
internal class EnvironmentDetectionRuleWithResult<T>                     // Rules that return specific values

LLM Detection with Multiple Environment Support

The LLM detection uses the rule-based approach with result values and supports detecting multiple LLM environments simultaneously:

// Telemetry property  
{LLM, _llmEnvironmentDetector.GetLLMEnvironment() }

// Detection logic using rule-based approach supporting multiple environments
private static readonly EnvironmentDetectionRuleWithResult<string>[] _detectionRules = [
    new EnvironmentDetectionRuleWithResult<string>("claude", "CLAUDECODE"),
    new EnvironmentDetectionRuleWithResult<string>("cursor", "CURSOR_EDITOR")
];

public string? GetLLMEnvironment()
{
    var results = _detectionRules.Select(r => r.GetResult()).Where(r => r != null).ToArray();
    return results.Length > 0 ? string.Join(", ", results) : null;
}

CI Detection Refactoring

Converted the existing CI detection to use the same rule-based approach while maintaining exact functionality:

private static readonly EnvironmentDetectionRule[] _detectionRules = [
    new BooleanEnvironmentRule("TF_BUILD", "GITHUB_ACTIONS", "APPVEYOR", "CI", "TRAVIS", "CIRCLECI"),
    new AllPresentEnvironmentRule("CODEBUILD_BUILD_ID", "AWS_REGION"),
    new AllPresentEnvironmentRule("BUILD_ID", "BUILD_URL"),
    // ... more rules
];

Benefits

• Extensible: Easy to add new environment types or detection rules
• Declarative: Rules are defined as data rather than procedural code
• Type-safe: Proper nullable reference type annotations throughout
• Maintainable: Centralized detection logic with clear separation of concerns
• Consistent: Both CI and LLM detection use the same underlying system
• Future-proof: Supports multiple LLM environments simultaneously with comma-separated output

Testing

All telemetry tests pass. The LLM detection includes 4 comprehensive test cases:

• CLAUDECODE with value → "claude"
• CURSOR_EDITOR with value → "cursor"
• Both environments → "claude, cursor"
• No environment variables → null

Manual testing confirms CLI correctly detects LLM environments and builds succeed without warnings.

Fixes #50641.

@baronfel's note: I've reviewed the code and am satisfied with it - need second approval to merge.

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.