Fix code style

Author: CapulusCodeNinja

mcp_nexus/CommandQueue/CommandQueueService.cs

@@ -77,10 +77,10 @@ public string QueueCommand(string command)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             if (string.IsNullOrWhiteSpace(command))
                 throw new ArgumentException("Command cannot be null or empty", nameof(command));
-            
+
             var commandId = Guid.NewGuid().ToString();
             m_logger.LogInformation("🔄 QueueCommand START: {CommandId} for command: {Command}", commandId, command);
 
@@ -108,10 +108,10 @@ public Task<string> GetCommandResult(string commandId)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             if (string.IsNullOrEmpty(commandId))
                 return Task.FromResult($"Command not found: {commandId}");
-                
+
             // NOTE: Completed commands stay in m_activeCommands for result retrieval
             if (m_activeCommands.TryGetValue(commandId, out var command))
             {
@@ -142,10 +142,10 @@ public bool CancelCommand(string commandId)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             if (string.IsNullOrEmpty(commandId))
                 return false;
-                
+
             // First check if command is in active commands (executing or completed)
             if (m_activeCommands.TryGetValue(commandId, out var command))
             {
@@ -180,7 +180,7 @@ public bool CancelCommand(string commandId)
             if (queuedCommand != null)
             {
                 m_logger.LogInformation("Cancelling queued command {CommandId}: {Command}", commandId, queuedCommand.Command);
-                
+
                 try
                 {
                     queuedCommand.CancellationTokenSource.Cancel();
@@ -202,7 +202,7 @@ public int CancelAllCommands(string? reason = null)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             var reasonText = string.IsNullOrWhiteSpace(reason) ? "No reason provided" : reason;
             m_logger.LogWarning("Cancelling ALL commands. Reason: {Reason}", reasonText);
 
@@ -266,7 +266,7 @@ public int CancelAllCommands(string? reason = null)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             lock (m_currentCommandLock)
             {
                 return m_currentCommand;
@@ -277,7 +277,7 @@ public int CancelAllCommands(string? reason = null)
         {
             if (m_disposed)
                 throw new ObjectDisposedException(nameof(CommandQueueService));
-                
+
             var results = new List<(string, string, DateTime, string)>();
 
             // Add current command
@@ -336,7 +336,7 @@ private async Task ProcessCommandQueue()
                         {
                             m_currentCommand = queuedCommand;
                         }
-                        
+
                         // Update command state to executing
                         UpdateCommandState(queuedCommand.Id, CommandState.Executing);
 
@@ -360,12 +360,12 @@ private async Task ProcessCommandQueue()
                             var resultMessage = queuedCommand.CancellationTokenSource.Token.IsCancellationRequested
                                 ? "Command execution was cancelled."
                                 : result;
-                            
+
                             var wasCompleted = queuedCommand.CompletionSource.TrySetResult(resultMessage);
-                            
+
                             // Update state atomically - this is safe even if another thread modified the command
                             UpdateCommandState(queuedCommand.Id, CommandState.Completed);
-                            
+
                             if (wasCompleted)
                             {
                                 Interlocked.Increment(ref m_commandsProcessed);
@@ -374,13 +374,13 @@ private async Task ProcessCommandQueue()
                             {
                                 m_logger.LogDebug("Command {CommandId} was already completed by another thread (race condition handled)", queuedCommand.Id);
                             }
-                            
+
                             LogConcurrencyStats();
                         }
                         catch (OperationCanceledException)
                         {
                             m_logger.LogInformation("Command {CommandId} was cancelled during execution", queuedCommand.Id);
-                            
+
                             // FIXED: Use TrySetResult to prevent double-completion and update state
                             var wasCompleted = queuedCommand.CompletionSource.TrySetResult("Command execution was cancelled.");
                             if (wasCompleted)
@@ -392,13 +392,13 @@ private async Task ProcessCommandQueue()
                             {
                                 m_logger.LogDebug("Command {CommandId} was already completed by another thread during cancellation", queuedCommand.Id);
                             }
-                            
+
                             LogConcurrencyStats();
                         }
                         catch (Exception ex)
                         {
                             m_logger.LogError(ex, "Error executing command {CommandId}: {Command}", queuedCommand.Id, queuedCommand.Command);
-                            
+
                             // IMPROVED: Better error handling with detailed error information
                             var errorMessage = ex switch
                             {
@@ -408,10 +408,10 @@ private async Task ProcessCommandQueue()
                                 ArgumentException => $"Invalid argument: {ex.Message}",
                                 _ => $"Command execution failed: {ex.GetType().Name}: {ex.Message}"
                             };
-                            
+
                             var wasCompleted = queuedCommand.CompletionSource.TrySetResult(errorMessage);
                             UpdateCommandState(queuedCommand.Id, CommandState.Failed);
-                            
+
                             if (wasCompleted)
                             {
                                 Interlocked.Increment(ref m_commandsFailed);
@@ -420,7 +420,7 @@ private async Task ProcessCommandQueue()
                             {
                                 m_logger.LogDebug("Command {CommandId} was already completed by another thread during error handling", queuedCommand.Id);
                             }
-                            
+
                             LogConcurrencyStats();
                         }
                         finally
@@ -482,14 +482,14 @@ private void LogConcurrencyStats()
                 var failed = Interlocked.Read(ref m_commandsFailed);
                 var cancelled = Interlocked.Read(ref m_commandsCancelled);
                 var total = processed + failed + cancelled;
-                
+
                 if (total > 0)
                 {
                     var successRate = total > 0 ? (double)processed / total * 100 : 0;
-                    m_logger.LogInformation("Concurrency Stats - Processed: {Processed}, Failed: {Failed}, Cancelled: {Cancelled}, Success Rate: {SuccessRate:F1}%", 
+                    m_logger.LogInformation("Concurrency Stats - Processed: {Processed}, Failed: {Failed}, Cancelled: {Cancelled}, Success Rate: {SuccessRate:F1}%",
                         processed, failed, cancelled, successRate);
                 }
-                
+
                 m_lastStatsLog = now;
             }
         }
@@ -508,8 +508,8 @@ private void CleanupCompletedCommands(object? state)
                 // PERFORMANCE: Use ValueTuple to avoid boxing in foreach
                 foreach (var (key, command) in m_activeCommands)
                 {
-                    if (command.State == CommandState.Completed || 
-                        command.State == CommandState.Cancelled || 
+                    if (command.State == CommandState.Completed ||
+                        command.State == CommandState.Cancelled ||
                         command.State == CommandState.Failed)
                     {
                         if (command.QueueTime < cutoffTime)

mcp_nexus/CommandQueue/IsolatedCommandQueueService.cs

@@ -20,37 +20,37 @@ public class IsolatedCommandQueueService : ICommandQueueService, IDisposable
         private readonly string m_sessionId;
         private readonly ILogger m_logger;
         private readonly IMcpNotificationService m_notificationService;
-        
+
         // CONCURRENCY: Thread-safe collections
         private readonly ConcurrentQueue<QueuedCommand> m_commandQueue = new();
         private readonly ConcurrentDictionary<string, QueuedCommand> m_activeCommands = new();
-        
+
         // SYNCHRONIZATION: Semaphore for queue processing
         private readonly SemaphoreSlim m_queueSemaphore = new(0, int.MaxValue);
-        
+
         // CURRENT COMMAND: Thread-safe current command tracking
         private volatile QueuedCommand? m_currentCommand;
         private readonly object m_currentCommandLock = new();
-        
+
         // LIFECYCLE: Cancellation and disposal
         private readonly CancellationTokenSource m_processingCts = new();
         private readonly Task m_processingTask;
         private volatile bool m_disposed = false;
-        
+
         // COUNTERS: Thread-safe performance tracking
         private long m_commandCounter = 0;
         private long m_completedCommands = 0;
         private long m_failedCommands = 0;
         private long m_cancelledCommands = 0;
-        
+
         // CONFIGURATION: Timeout settings
         private readonly TimeSpan m_defaultCommandTimeout = TimeSpan.FromMinutes(10);
         private readonly TimeSpan m_heartbeatInterval = TimeSpan.FromSeconds(30);
 
         public IsolatedCommandQueueService(
-            ICdbSession cdbSession, 
-            ILogger logger, 
-            IMcpNotificationService notificationService, 
+            ICdbSession cdbSession,
+            ILogger logger,
+            IMcpNotificationService notificationService,
             string sessionId)
         {
             m_cdbSession = cdbSession ?? throw new ArgumentNullException(nameof(cdbSession));
@@ -77,7 +77,7 @@ public string QueueCommand(string command)
             var commandNumber = Interlocked.Increment(ref m_commandCounter);
             var commandId = $"cmd-{m_sessionId}-{commandNumber:D4}";
 
-            m_logger.LogDebug("🔄 Queueing command {CommandId} in session {SessionId}: {Command}", 
+            m_logger.LogDebug("🔄 Queueing command {CommandId} in session {SessionId}: {Command}",
                 commandId, m_sessionId, command);
 
             // IMMUTABLE: Create command object
@@ -111,7 +111,7 @@ public string QueueCommand(string command)
                     try
                     {
                         await m_notificationService.NotifyCommandStatusAsync(
-                            m_sessionId, commandId, command, "queued", 
+                            m_sessionId, commandId, command, "queued",
                             result: null, progress: 0);
                     }
                     catch (Exception ex)
@@ -234,7 +234,7 @@ public int CancelAllCommands(string? reason = null)
                 m_logger.LogWarning(ex, "Error cancelling current CDB operation during bulk cancel");
             }
 
-            m_logger.LogInformation("🚫 Cancelled {Count} commands in session {SessionId}: {Reason}", 
+            m_logger.LogInformation("🚫 Cancelled {Count} commands in session {SessionId}: {Reason}",
                 cancelledCount, m_sessionId, reason ?? "Bulk cancellation");
 
             return cancelledCount;
@@ -338,7 +338,7 @@ private async Task ExecuteCommandSafely(QueuedCommand command)
                     CompleteCommandSafely(command, result, CommandState.Completed);
                     Interlocked.Increment(ref m_completedCommands);
 
-                    m_logger.LogInformation("✅ Command {CommandId} completed in {ElapsedMs}ms", 
+                    m_logger.LogInformation("✅ Command {CommandId} completed in {ElapsedMs}ms",
                         command.Id, stopwatch.ElapsedMilliseconds);
                 }
                 finally
@@ -365,7 +365,7 @@ private async Task ExecuteCommandSafely(QueuedCommand command)
                 CompleteCommandSafely(command, $"Command execution failed: {ex.Message}", CommandState.Failed);
                 Interlocked.Increment(ref m_failedCommands);
 
-                m_logger.LogError(ex, "❌ Command {CommandId} failed after {ElapsedMs}ms", 
+                m_logger.LogError(ex, "❌ Command {CommandId} failed after {ElapsedMs}ms",
                     command.Id, stopwatch.ElapsedMilliseconds);
             }
             finally
@@ -508,7 +508,7 @@ public void Dispose()
                 // CLEANUP: Dispose resources
                 m_queueSemaphore.Dispose();
                 m_processingCts.Dispose();
-                
+
                 // CLEANUP: Dispose processing task
                 try
                 {