Merge branch 'main' of https://github.com/willibrandon/NetContextServer

willibrandon · willibrandon · commit 9364d798dfd1 · 2025-04-17T14:47:53.000-07:00
diff --git a/README.md b/README.md
@@ -4,7 +4,7 @@
 
 🔍 **Supercharge Your AI Coding Assistant with Deep .NET Codebase Understanding**
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Built with .NET](https://img.shields.io/badge/Built%20with-.NET-512BD4)](https://dotnet.microsoft.com/)
 [![MCP Compatible](https://img.shields.io/badge/MCP-Compatible-brightgreen)](https://modelcontextprotocol.io/)
 [![.NET Build and Test](https://github.com/willibrandon/NetContextServer/actions/workflows/ci.yaml/badge.svg)](https://github.com/willibrandon/NetContextServer/actions/workflows/ci.yaml)
@@ -161,17 +161,22 @@ dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-di
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- get-base-dir
 ```
 
-3. **List Projects**:
+3. **Get Version Information**:
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- version
+```
+
+4. **List Projects**:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "D:\YourProject\src"
 ```
 
-4. **List Source Files**:
+5. **List Source Files**:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-source-files --project-dir "D:\YourProject\src\YourProject"
 ```
 
-5. **Analyze Packages**:
+6. **Analyze Packages**:
 ```bash
 # Set your base directory first
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project"
@@ -201,7 +206,7 @@ Project: MyProject.csproj
           └─ Microsoft.Extensions.DependencyInjection.Abstractions
 ```
 
-6. **Analyze Test Coverage**:
+7. **Analyze Test Coverage**:
 ```bash
 # Set your base directory first
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "path/to/your/project"
@@ -302,22 +307,27 @@ The following patterns are ignored by default to protect sensitive information:
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- set-base-dir --directory "D:\Projects\MyApp"
 ```
 
-2. Set up custom ignore patterns:
+2. Check server version and configuration:
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- version
+```
+
+3. Set up custom ignore patterns:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- add-ignore-patterns --patterns "*.generated.cs" "*.designer.cs"
 ```
 
-3. List all projects:
+4. List all projects:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- list-projects-in-dir --directory "D:\Projects\MyApp\src"
 ```
 
-4. Analyze your project's package dependencies:
+5. Analyze your project's package dependencies:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- analyze-packages
 ```
 
-5. Search for authentication-related code:
+6. Search for authentication-related code:
 ```bash
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- semantic-search --query "user authentication and authorization logic"
 ```
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
@@ -269,6 +269,44 @@ Simple health check endpoint that returns a greeting message.
 dotnet run --project src/NetContextClient/NetContextClient.csproj -- hello
 ```
 
+### `version`
+Gets version and configuration information about the NetContextServer.
+
+**Parameters:** None
+
+**Example:**
+```bash
+dotnet run --project src/NetContextClient/NetContextClient.csproj -- version
+```
+
+**Output Example:**
+```
+NetContextServer v1.0.0
+──────────────────────────────────────────────────────
+
+System Information:
+  • Runtime: .NET 9.0.0
+  • OS: Unix 24.1.0
+
+Features:
+  • Semantic Search: ✗ Disabled
+
+Active Configuration:
+  • Base Directory: /Users/username/projects/myapp
+  • Has Ignore Patterns: true
+  • State File Location: /Users/username/projects/myapp/ignore_patterns.json
+```
+
+**Response Fields:**
+- `version`: Current version of NetContextServer
+- `runtimeVersion`: Current .NET runtime version
+- `operatingSystem`: Current operating system information
+- `semanticSearchEnabled`: Whether semantic search is configured and available
+- `activeConfiguration`: Dictionary of current configuration settings including:
+  - `BaseDirectory`: Current base directory for file operations
+  - `HasIgnorePatterns`: Whether custom ignore patterns are defined
+  - `StateFileLocation`: Path to the ignore patterns state file
+
 ### `think`
 Provides a space for structured thinking during complex operations, allowing AI models to reason about actions, verify compliance with rules, and plan next steps without making any state changes.
 
diff --git a/src/NetContextClient/Models/VersionResponse.cs b/src/NetContextClient/Models/VersionResponse.cs
@@ -0,0 +1,39 @@
+using System.Text.Json.Serialization;
+
+namespace NetContextClient.Models;
+
+/// <summary>
+/// Response model for version information.
+/// </summary>
+public class VersionResponse
+{
+    /// <summary>
+    /// Gets the current version of NetContextServer.
+    /// </summary>
+    [JsonPropertyName("version")]
+    public string Version { get; init; } = string.Empty;
+
+    /// <summary>
+    /// Gets the current .NET runtime version.
+    /// </summary>
+    [JsonPropertyName("runtimeVersion")]
+    public string RuntimeVersion { get; init; } = string.Empty;
+
+    /// <summary>
+    /// Gets whether semantic search is configured and available.
+    /// </summary>
+    [JsonPropertyName("semanticSearchEnabled")]
+    public bool SemanticSearchEnabled { get; init; }
+
+    /// <summary>
+    /// Gets the current operating system.
+    /// </summary>
+    [JsonPropertyName("operatingSystem")]
+    public string OperatingSystem { get; init; } = string.Empty;
+
+    /// <summary>
+    /// Gets active configuration settings.
+    /// </summary>
+    [JsonPropertyName("activeConfiguration")]
+    public Dictionary<string, string> ActiveConfiguration { get; init; } = new();
+} 
diff --git a/src/NetContextClient/Program.cs b/src/NetContextClient/Program.cs
@@ -923,6 +923,76 @@ static async Task<int> Main(string[] args)
             }
         }, reportPathOption, formatOption);
 
+        // Version command
+        var versionCommand = new Command("version", "Get version and configuration information");
+        versionCommand.SetHandler(async () =>
+        {
+            try
+            {
+                var result = await client.CallToolAsync("version", new Dictionary<string, object?>());
+                var jsonText = result.Content.First(c => c.Type == "text").Text;
+                if (jsonText != null)
+                {
+                    var response = JsonSerializer.Deserialize<VersionResponse>(jsonText, DefaultJsonOptions);
+                    if (response != null)
+                    {
+                        // Parse state file location first if it exists
+                        if (response.ActiveConfiguration.TryGetValue("StateFileLocation", out var stateFileJson))
+                        {
+                            var stateFile = JsonSerializer.Deserialize<StateFileLocationResponse>(stateFileJson);
+                            response.ActiveConfiguration["StateFileLocation"] = stateFile?.StateFilePath ?? stateFileJson;
+                        }
+
+                        // Header with version
+                        await Console.Out.WriteLineAsync($"\u001b[1;36mNetContextServer\u001b[0m v{response.Version}");
+                        await Console.Out.WriteLineAsync(new string('─', 50));
+                        
+                        // System Information
+                        await Console.Out.WriteLineAsync("\u001b[1;33mSystem Information:\u001b[0m");
+                        await Console.Out.WriteLineAsync($"  \u001b[90m•\u001b[0m Runtime: \u001b[32m.NET {response.RuntimeVersion}\u001b[0m");
+                        await Console.Out.WriteLineAsync($"  \u001b[90m•\u001b[0m OS: \u001b[32m{response.OperatingSystem}\u001b[0m");
+                        
+                        // Features
+                        await Console.Out.WriteLineAsync("\n\u001b[1;33mFeatures:\u001b[0m");
+                        await Console.Out.WriteLineAsync($"  \u001b[90m•\u001b[0m Semantic Search: {(response.SemanticSearchEnabled ? "\u001b[32m✓ Enabled\u001b[0m" : "\u001b[31m✗ Disabled\u001b[0m")}");
+                        
+                        // Configuration
+                        if (response.ActiveConfiguration.Count > 0)
+                        {
+                            await Console.Out.WriteLineAsync("\n\u001b[1;33mActive Configuration:\u001b[0m");
+                            foreach (var (key, value) in response.ActiveConfiguration)
+                            {
+                                // Format key in a more readable way
+                                var displayKey = string.Join(" ", key.Split(new[] { '_' }, StringSplitOptions.RemoveEmptyEntries)
+                                    .Select(word => char.ToUpper(word[0]) + word.Substring(1)));
+                                
+                                // Special formatting for boolean values and paths
+                                string displayValue = value;
+                                if (bool.TryParse(value, out bool boolValue))
+                                {
+                                    displayValue = boolValue ? "\u001b[32m✓ Yes\u001b[0m" : "\u001b[31m✗ No\u001b[0m";
+                                }
+                                else if (value.Contains(Path.DirectorySeparatorChar))
+                                {
+                                    displayValue = $"\u001b[36m{value}\u001b[0m";
+                                }
+
+                                await Console.Out.WriteLineAsync($"  \u001b[90m•\u001b[0m {displayKey}: {displayValue}");
+                            }
+                        }
+                        
+                        // Footer
+                        await Console.Out.WriteLineAsync(new string('─', 50));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                await Console.Error.WriteLineAsync($"\u001b[31mError: {ex.Message}\u001b[0m");
+                Environment.Exit(1);
+            }
+        });
+
         rootCommand.AddCommand(helloCommand);
         rootCommand.AddCommand(setBaseDirCommand);
         rootCommand.AddCommand(getBaseDirCommand);
@@ -943,6 +1013,7 @@ static async Task<int> Main(string[] args)
         rootCommand.AddCommand(thinkCommand);
         rootCommand.AddCommand(coverageAnalysisCommand);
         rootCommand.AddCommand(coverageSummaryCommand);
+        rootCommand.AddCommand(versionCommand);
         
         return await rootCommand.InvokeAsync(args);
     }
diff --git a/src/NetContextServer/Models/VersionInfo.cs b/src/NetContextServer/Models/VersionInfo.cs
@@ -0,0 +1,39 @@
+using System.Text.Json.Serialization;
+
+namespace NetContextServer.Models;
+
+/// <summary>
+/// Represents version and configuration information for the NetContextServer.
+/// </summary>
+public class VersionInfo
+{
+    /// <summary>
+    /// Gets the current version of NetContextServer.
+    /// </summary>
+    [JsonPropertyName("version")]
+    public string Version { get; init; } = typeof(VersionInfo).Assembly.GetName().Version?.ToString() ?? "unknown";
+
+    /// <summary>
+    /// Gets the current .NET runtime version.
+    /// </summary>
+    [JsonPropertyName("runtimeVersion")]
+    public string RuntimeVersion { get; init; } = Environment.Version.ToString();
+
+    /// <summary>
+    /// Gets whether semantic search is configured and available.
+    /// </summary>
+    [JsonPropertyName("semanticSearchEnabled")]
+    public bool SemanticSearchEnabled { get; init; }
+
+    /// <summary>
+    /// Gets the current operating system.
+    /// </summary>
+    [JsonPropertyName("operatingSystem")]
+    public string OperatingSystem { get; init; } = Environment.OSVersion.ToString();
+
+    /// <summary>
+    /// Gets active configuration settings.
+    /// </summary>
+    [JsonPropertyName("activeConfiguration")]
+    public Dictionary<string, string> ActiveConfiguration { get; init; } = new();
+} 
diff --git a/src/NetContextServer/Services/IgnorePatternService.cs b/src/NetContextServer/Services/IgnorePatternService.cs
@@ -241,4 +241,13 @@ public static bool ShouldIgnoreFile(string filePath)
             return Path.GetFileName(filePath).Equals(pattern, StringComparison.OrdinalIgnoreCase);
         });
     }
+
+    /// <summary>
+    /// Checks if there are any user-defined ignore patterns.
+    /// </summary>
+    /// <returns>True if there are user-defined patterns, false otherwise.</returns>
+    public static bool HasUserDefinedPatterns()
+    {
+        return UserIgnorePatterns.Count > 0;
+    }
 }
diff --git a/src/NetContextServer/Services/VersionService.cs b/src/NetContextServer/Services/VersionService.cs
@@ -0,0 +1,28 @@
+using NetContextServer.Models;
+
+namespace NetContextServer.Services;
+
+/// <summary>
+/// Service for retrieving version and configuration information about the NetContextServer.
+/// </summary>
+public static class VersionService
+{
+    /// <summary>
+    /// Gets the current version information for NetContextServer.
+    /// </summary>
+    /// <returns>A VersionInfo object containing current version and configuration details.</returns>
+    public static VersionInfo GetVersionInfo()
+    {
+        return new VersionInfo
+        {
+            SemanticSearchEnabled = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")) &&
+                                  !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")),
+            ActiveConfiguration = new Dictionary<string, string>
+            {
+                ["BaseDirectory"] = FileValidationService.BaseDirectory ?? "Not set",
+                ["HasIgnorePatterns"] = IgnorePatternService.HasUserDefinedPatterns().ToString(),
+                ["StateFileLocation"] = IgnorePatternService.GetStateFileLocation()
+            }
+        };
+    }
+} 
diff --git a/src/NetContextServer/Tools/GeneralTools.cs b/src/NetContextServer/Tools/GeneralTools.cs
@@ -1,5 +1,7 @@
 using ModelContextProtocol.Server;
+using NetContextServer.Services;
 using System.ComponentModel;
+using System.Text.Json;
 
 namespace NetContextServer.Tools;
 
@@ -9,11 +11,28 @@ namespace NetContextServer.Tools;
 [McpServerToolType]
 public static class GeneralTools
 {
+    /// <summary>
+    /// Default JSON serializer options used for version information output.
+    /// </summary>
+    private static readonly JsonSerializerOptions DefaultJsonOptions = new()
+    {
+        WriteIndented = true
+    };
+
     /// <summary>
     /// Simple health check endpoint that returns a greeting message.
     /// </summary>
     /// <returns>A greeting message indicating the server is operational.</returns>
     [McpServerTool("hello")]
     [Description("Simple health check endpoint that returns a greeting message.")]
     public static string Hello() => "hello, claude.";
+
+    /// <summary>
+    /// Gets version and configuration information about the NetContextServer.
+    /// </summary>
+    /// <returns>A JSON string containing version information and current configuration.</returns>
+    [McpServerTool("version")]
+    [Description("Gets version and configuration information about the NetContextServer.")]
+    public static string GetVersion() => 
+        JsonSerializer.Serialize(VersionService.GetVersionInfo(), DefaultJsonOptions);
 }
diff --git a/tests/NetContextServer/GeneralOperationTests.cs b/tests/NetContextServer/GeneralOperationTests.cs
diff --git a/tests/NetContextServer/Services/VersionServiceTests.cs b/tests/NetContextServer/Services/VersionServiceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -241,4 +241,13 @@ public static bool ShouldIgnoreFile(string filePath)`
`241`	`241`	`return Path.GetFileName(filePath).Equals(pattern, StringComparison.OrdinalIgnoreCase);`
`242`	`242`	`});`
`243`	`243`	`}`
	`244`	`+`
	`245`	`+ /// <summary>`
	`246`	`+ /// Checks if there are any user-defined ignore patterns.`
	`247`	`+ /// </summary>`
	`248`	`+ /// <returns>True if there are user-defined patterns, false otherwise.</returns>`
	`249`	`+ public static bool HasUserDefinedPatterns()`
	`250`	`+ {`
	`251`	`+ return UserIgnorePatterns.Count > 0;`
	`252`	`+ }`
`244`	`253`	`}`