Enhance the command preprocessor

Author: CapulusCodeNinja

README.md

@@ -2,7 +2,7 @@
 
 **AI-Powered Windows Crash Dump Analysis Platform**
 
-[![Tests](https://img.shields.io/badge/tests-1,861%20total-brightgreen?style=flat-square)](https://github.com/CapulusCodeNinja/mcp_nexus)
+[![Tests](https://img.shields.io/badge/tests-1,853%20total-brightgreen?style=flat-square)](https://github.com/CapulusCodeNinja/mcp_nexus)
 [![Coverage](https://img.shields.io/badge/coverage-62.62%25-good?style=flat-square)](https://github.com/CapulusCodeNinja/mcp_nexus)
 [![Build](https://img.shields.io/badge/build-0%20warnings-brightgreen?style=flat-square)](https://github.com/CapulusCodeNinja/mcp_nexus)
 [![License](https://img.shields.io/badge/license-Apache%202.0-blue?style=flat-square)](LICENSE)
@@ -317,7 +317,7 @@ dotnet test --filter "Notification"
 
 ### Test Statistics
 
-- ✅ **1,861 total tests** (1,861 passing)
+- ✅ **1,853 total tests** (1,853 passing)
 - ✅ **62.62% line coverage** with comprehensive analysis testing
 - ✅ **0 warnings** in build (clean codebase)
 - ✅ **17+ test categories** covering all major functionality including Extensions

mcp_nexus/Configuration/ServiceRegistration.cs

@@ -136,7 +136,12 @@ private static void RegisterCoreServices(IServiceCollection services, IConfigura
             services.AddSingleton<IMcpNotificationService, McpNotificationService>();
             services.AddSingleton<IMcpToolDefinitionService, McpToolDefinitionService>();
 
-            logger.Info("Registered core services (CDB, Session, Notifications, Protocol)");
+            // Register utility services for path handling and command preprocessing
+            services.AddSingleton<mcp_nexus.Utilities.IWslPathConverter, mcp_nexus.Utilities.WslPathConverter>();
+            services.AddSingleton<mcp_nexus.Utilities.IPathHandler, mcp_nexus.Utilities.PathHandler>();
+            services.AddSingleton<mcp_nexus.Utilities.ICommandPreprocessor, mcp_nexus.Utilities.CommandPreprocessor>();
+
+            logger.Info("Registered core services (CDB, Session, Notifications, Protocol, Utilities)");
         }
 
 

mcp_nexus/Debugger/CdbSession.cs

@@ -13,6 +13,7 @@ public class CdbSession : IDisposable, ICdbSession
         private readonly CdbProcessManager m_processManager;
         private readonly CdbCommandExecutor m_commandExecutor;
         private readonly CdbOutputParser m_outputParser;
+        private readonly mcp_nexus.Utilities.ICommandPreprocessor? m_commandPreprocessor;
 
         // CRITICAL: Semaphore to ensure only ONE command executes at a time in CDB
         // CDB is single-threaded and cannot handle concurrent commands
@@ -34,6 +35,7 @@ public class CdbSession : IDisposable, ICdbSession
         /// <param name="outputReadingTimeoutMs">The output reading timeout in milliseconds. Default is 300000ms (5 minutes).</param>
         /// <param name="enableCommandPreprocessing">Whether to enable command preprocessing (path conversion and directory creation). Default is true.</param>
         /// <param name="sessionId">Optional session ID for creating session-specific log files. If null, uses default naming.</param>
+        /// <param name="commandPreprocessor">Optional command preprocessor for path conversion. If null and preprocessing is enabled, preprocessing will be skipped.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="logger"/> is null.</exception>
         public CdbSession(
             ILogger<CdbSession> logger,
@@ -45,9 +47,11 @@ public CdbSession(
             int startupDelayMs = 1000,
             int outputReadingTimeoutMs = 300000,
             bool enableCommandPreprocessing = true,
-            string? sessionId = null)
+            string? sessionId = null,
+            mcp_nexus.Utilities.ICommandPreprocessor? commandPreprocessor = null)
         {
             m_logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            m_commandPreprocessor = commandPreprocessor;
 
             // Create configuration with validation
             m_config = new CdbSessionConfiguration(
@@ -86,14 +90,17 @@ public CdbSession(
         /// <param name="logger">The logger instance for recording session operations and errors.</param>
         /// <param name="config">The CDB session configuration object.</param>
         /// <param name="sessionId">Optional session ID for creating session-specific log files. If null, uses default naming.</param>
+        /// <param name="commandPreprocessor">Optional command preprocessor for path conversion. If null and preprocessing is enabled, preprocessing will be skipped.</param>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="logger"/> or <paramref name="config"/> is null.</exception>
         public CdbSession(
             ILogger<CdbSession> logger,
             CdbSessionConfiguration config,
-            string? sessionId = null)
+            string? sessionId = null,
+            mcp_nexus.Utilities.ICommandPreprocessor? commandPreprocessor = null)
         {
             m_logger = logger ?? throw new ArgumentNullException(nameof(logger));
             m_config = config ?? throw new ArgumentNullException(nameof(config));
+            m_commandPreprocessor = commandPreprocessor;
 
             // CRITICAL FIX: Logger casting was failing, causing NullLogger to be used!
             // This resulted in zero visibility into CdbProcessManager init consumer
@@ -311,16 +318,20 @@ public async Task<string> ExecuteCommand(string command, string commandId, Cance
                 m_logger.LogInformation("🔒 SEMAPHORE: About to execute command '{Command}' (TRUE ASYNC)", command);
 
                 // Preprocess the command to fix common issues (e.g., .srcpath path conversion and directory creation)
-                // Only if preprocessing is enabled in configuration
+                // Only if preprocessing is enabled in configuration and preprocessor is available
                 var preprocessedCommand = command;
-                if (m_config.EnableCommandPreprocessing)
+                if (m_config.EnableCommandPreprocessing && m_commandPreprocessor != null)
                 {
-                    preprocessedCommand = mcp_nexus.Utilities.CommandPreprocessor.PreprocessCommand(command);
+                    preprocessedCommand = m_commandPreprocessor.PreprocessCommand(command);
                     if (preprocessedCommand != command)
                     {
                         m_logger.LogInformation("🔧 Command preprocessed: '{Original}' -> '{Preprocessed}'", command, preprocessedCommand);
                     }
                 }
+                else if (m_config.EnableCommandPreprocessing && m_commandPreprocessor == null)
+                {
+                    m_logger.LogWarning("⚠️ Command preprocessing is ENABLED but no preprocessor provided - sending command as-is: '{Command}'", command);
+                }
                 else
                 {
                     m_logger.LogDebug("⚠️ Command preprocessing is DISABLED - sending command as-is: '{Command}'", command);

mcp_nexus/Session/SessionLifecycleManager.cs

@@ -21,21 +21,24 @@ namespace mcp_nexus.Session
     /// <param name="notificationService">The notification service for sending session events.</param>
     /// <param name="config">The session manager configuration.</param>
     /// <param name="sessions">The thread-safe dictionary for storing session information.</param>
+    /// <param name="commandPreprocessor">The command preprocessor for path conversions.</param>
     /// <exception cref="ArgumentNullException">Thrown when any of the required parameters are null.</exception>
     public class SessionLifecycleManager(
         ILogger logger,
         IServiceProvider serviceProvider,
         ILoggerFactory loggerFactory,
         IMcpNotificationService notificationService,
         SessionManagerConfiguration config,
-        ConcurrentDictionary<string, SessionInfo> sessions)
+        ConcurrentDictionary<string, SessionInfo> sessions,
+        mcp_nexus.Utilities.ICommandPreprocessor commandPreprocessor)
     {
         private readonly ILogger m_Logger = logger ?? throw new ArgumentNullException(nameof(logger));
         private readonly IServiceProvider m_ServiceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
         private readonly ILoggerFactory m_LoggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
         private readonly IMcpNotificationService m_NotificationService = notificationService ?? throw new ArgumentNullException(nameof(notificationService));
         private readonly SessionManagerConfiguration m_Config = config ?? throw new ArgumentNullException(nameof(config));
         private readonly ConcurrentDictionary<string, SessionInfo> m_Sessions = sessions ?? throw new ArgumentNullException(nameof(sessions));
+        private readonly mcp_nexus.Utilities.ICommandPreprocessor m_CommandPreprocessor = commandPreprocessor ?? throw new ArgumentNullException(nameof(commandPreprocessor));
         private readonly ConcurrentDictionary<string, SessionCommandResultCache> m_SessionCaches = new ConcurrentDictionary<string, SessionCommandResultCache>();
         private readonly IExtensionCommandTracker? m_ExtensionTracker = serviceProvider.GetService<IExtensionCommandTracker>();
         private readonly IExtensionExecutor? m_ExtensionExecutor = serviceProvider.GetService<IExtensionExecutor>();
@@ -424,7 +427,8 @@ private ICdbSession CreateCdbSession(ILogger sessionLogger, string sessionId)
                 m_Config.CdbOptions.StartupDelayMs,
                 m_Config.CdbOptions.OutputReadingTimeoutMs,
                 m_Config.CdbOptions.EnableCommandPreprocessing,
-                sessionId
+                sessionId,
+                m_CommandPreprocessor
             );
         }
 

mcp_nexus/Session/ThreadSafeSessionManager.cs

@@ -52,8 +52,9 @@ public ThreadSafeSessionManager(
 
             // Create focused components
             m_config = new SessionManagerConfiguration(config, cdbOptions);
+            var commandPreprocessor = serviceProvider.GetRequiredService<mcp_nexus.Utilities.ICommandPreprocessor>();
             m_lifecycleManager = new SessionLifecycleManager(
-                logger, serviceProvider, loggerFactory, notificationService, m_config, m_sessions);
+                logger, serviceProvider, loggerFactory, notificationService, m_config, m_sessions, commandPreprocessor);
             m_monitoringService = new SessionMonitoringService(
                 logger, notificationService, m_config, m_sessions, m_lifecycleManager, m_shutdownCts);
             m_statisticsCollector = new SessionStatisticsCollector(

mcp_nexus/Utilities/CommandPreprocessor.cs

@@ -3,32 +3,43 @@
 namespace mcp_nexus.Utilities
 {
     /// <summary>
-    /// Preprocesses WinDBG commands for path conversion and directory creation only.
+    /// Service for preprocessing WinDBG commands for path conversion and directory creation.
     /// This class ONLY handles WSL to Windows path conversion and ensures directories exist.
     /// NO syntax fixing, NO adding quotes, NO adding semicolons.
+    /// Injectable service that supports proper dependency injection and testing.
     /// </summary>
-    public static partial class CommandPreprocessor
+    public partial class CommandPreprocessor : ICommandPreprocessor
     {
-        private static readonly Regex PathPattern = MyRegex();
+        private static readonly Regex s_PathPattern = MyRegex();
+        private readonly IPathHandler m_PathHandler;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CommandPreprocessor"/> class.
+        /// </summary>
+        /// <param name="pathHandler">The path handler for WSL/Windows path conversions.</param>
+        public CommandPreprocessor(IPathHandler pathHandler)
+        {
+            m_PathHandler = pathHandler ?? throw new ArgumentNullException(nameof(pathHandler));
+        }
 
         /// <summary>
         /// Preprocesses a WinDBG command to convert WSL paths to Windows paths and ensure directories exist.
         /// ONLY does path conversion - NO syntax changes.
         /// </summary>
         /// <param name="command">The original command</param>
         /// <returns>The command with paths converted</returns>
-        public static string PreprocessCommand(string command)
+        public string PreprocessCommand(string command)
         {
             if (string.IsNullOrWhiteSpace(command))
             {
                 return command;
             }
 
             // Find and convert all WSL paths in the command (generic /mnt/<drive>/...)
-            var result = PathPattern.Replace(command, match =>
+            var result = s_PathPattern.Replace(command, match =>
             {
                 var wslPath = match.Value;
-                var windowsPath = PathHandler.ConvertToWindowsPath(wslPath);
+                var windowsPath = m_PathHandler.ConvertToWindowsPath(wslPath);
 
                 // Ensure directory exists
                 EnsureDirectoryExists(windowsPath);
@@ -44,7 +55,7 @@ public static string PreprocessCommand(string command)
                     (Match m) =>
                     {
                         var wsl = m.Groups[1].Value.Replace('\\', '/');
-                        var win = PathHandler.ConvertToWindowsPath(wsl);
+                        var win = m_PathHandler.ConvertToWindowsPath(wsl);
                         return "srv*" + win;
                     },
                     RegexOptions.IgnoreCase);
@@ -109,7 +120,7 @@ public static string PreprocessCommand(string command)
         /// Ensures that a directory exists, creating it if necessary.
         /// </summary>
         /// <param name="path">The directory path to ensure exists</param>
-        private static void EnsureDirectoryExists(string path)
+        private void EnsureDirectoryExists(string path)
         {
             if (string.IsNullOrWhiteSpace(path))
                 return;
@@ -124,14 +135,13 @@ private static void EnsureDirectoryExists(string path)
                 }
 
                 // Check if it's a valid Windows path
-                if (PathHandler.IsWindowsPath(path))
+                if (m_PathHandler.IsWindowsPath(path))
                 {
                     // Create directory if it doesn't exist
                     if (!Directory.Exists(path))
                     {
                         Directory.CreateDirectory(path);
-                        // Note: We can't use ILogger here since this is a static utility class
-                        // Directory creation will be logged at the command execution level
+                        // Directory creation is logged at the command execution level if needed
                     }
                 }
             }

mcp_nexus/Utilities/ICommandPreprocessor.cs

@@ -0,0 +1,18 @@
+namespace mcp_nexus.Utilities
+{
+    /// <summary>
+    /// Interface for preprocessing WinDBG commands before execution.
+    /// Handles path conversion and directory creation.
+    /// </summary>
+    public interface ICommandPreprocessor
+    {
+        /// <summary>
+        /// Preprocesses a WinDBG command to convert WSL paths to Windows paths and ensure directories exist.
+        /// ONLY does path conversion - NO syntax changes.
+        /// </summary>
+        /// <param name="command">The original command.</param>
+        /// <returns>The command with paths converted.</returns>
+        string PreprocessCommand(string command);
+    }
+}
+

mcp_nexus/Utilities/IPathHandler.cs

@@ -0,0 +1,50 @@
+namespace mcp_nexus.Utilities
+{
+    /// <summary>
+    /// Interface for path conversion and handling operations.
+    /// Abstracts WSL path conversion, Windows path validation, and path normalization.
+    /// </summary>
+    public interface IPathHandler
+    {
+        /// <summary>
+        /// Converts a WSL path to a Windows path.
+        /// </summary>
+        /// <param name="path">The WSL path to convert.</param>
+        /// <returns>The converted Windows path.</returns>
+        string ConvertToWindowsPath(string path);
+
+        /// <summary>
+        /// Converts a Windows path to a WSL path.
+        /// </summary>
+        /// <param name="path">The Windows path to convert.</param>
+        /// <returns>The converted WSL path.</returns>
+        string ConvertToWslPath(string path);
+
+        /// <summary>
+        /// Normalizes a path for Windows by converting WSL paths if detected.
+        /// </summary>
+        /// <param name="path">The path to normalize.</param>
+        /// <returns>The normalized Windows path.</returns>
+        string NormalizeForWindows(string path);
+
+        /// <summary>
+        /// Normalizes multiple paths for Windows by converting WSL paths if detected.
+        /// </summary>
+        /// <param name="paths">The paths to normalize.</param>
+        /// <returns>The normalized Windows paths.</returns>
+        string[] NormalizeForWindows(string[] paths);
+
+        /// <summary>
+        /// Determines if a path is a Windows path.
+        /// </summary>
+        /// <param name="path">The path to check.</param>
+        /// <returns>True if the path is a Windows path; otherwise, false.</returns>
+        bool IsWindowsPath(string path);
+
+        /// <summary>
+        /// Clears the internal path conversion cache.
+        /// </summary>
+        void ClearCache();
+    }
+}
+

mcp_nexus/Utilities/IWslPathConverter.cs

@@ -0,0 +1,24 @@
+namespace mcp_nexus.Utilities
+{
+    /// <summary>
+    /// Interface for WSL path conversion operations.
+    /// This allows for mocking in tests.
+    /// </summary>
+    public interface IWslPathConverter
+    {
+        /// <summary>
+        /// Attempts to convert a WSL path to Windows format using wsl.exe.
+        /// </summary>
+        /// <param name="wslPath">The WSL path to convert</param>
+        /// <param name="windowsPath">The converted Windows path if successful</param>
+        /// <returns>True if conversion succeeded, false otherwise</returns>
+        bool TryConvertToWindowsPath(string wslPath, out string windowsPath);
+
+        /// <summary>
+        /// Attempts to load WSL mount mappings from /etc/fstab.
+        /// </summary>
+        /// <returns>Dictionary of mount point to Windows path mappings</returns>
+        Dictionary<string, string> LoadFstabMappings();
+    }
+}
+