extract command fields into one state

Author: xinyi-gong

com.microsoft.copilot.eclipse.terminal.api/src/com/microsoft/copilot/eclipse/terminal/api/TerminalCommandProcessor.java

@@ -125,27 +125,28 @@ public static CompletionCheckResult tryCompleteWithMarker(StringBuilder output,
       return CompletionCheckResult.incomplete();
     }
 
-    if (skipCompletion) {
+    // Keep command output plus the next prompt, but remove the command-finished marker itself, including exit code.
+    String completedOutput = output.substring(0, commandFinishMarkerRange.startIndex)
+        + output.substring(commandFinishMarkerRange.endIndex, promptEndMarkerRange.endIndex);
+    if (shouldSkipCompletion(completedOutput, activeCommand, skipCompletion)) {
       // This region belongs to a command that was interrupted by Ctrl+C. Drop it so it cannot complete the next
       // foreground command that may already be listening on the same terminal output buffer.
       output.delete(0, promptEndMarkerRange.endIndex);
       return CompletionCheckResult.skipped();
     }
-
-    // Keep command output plus the next prompt, but remove the command-finished marker itself, including exit code.
-    String completedOutput = output.substring(0, commandFinishMarkerRange.startIndex)
-        + output.substring(commandFinishMarkerRange.endIndex, promptEndMarkerRange.endIndex);
     return CompletionCheckResult.completed(cleanCommandOutput(completedOutput, activeCommand));
   }
 
   /**
    * Attempts to complete a command by detecting a shell prompt.
    *
    * @param output terminal output buffer
+   * @param activeCommand command currently being executed
    * @param skipCompletion whether to skip the next completed command region
    * @return the completion check result
    */
-  public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output, boolean skipCompletion) {
+  public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output, String activeCommand,
+      boolean skipCompletion) {
     String terminalOutput = output.toString().trim();
     int lastNewLineIndex = terminalOutput.lastIndexOf('\n');
     if (lastNewLineIndex <= 0) {
@@ -163,7 +164,7 @@ public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output,
       return CompletionCheckResult.incomplete();
     }
 
-    if (skipCompletion) {
+    if (shouldSkipCompletion(terminalOutput, activeCommand, skipCompletion)) {
       output.setLength(0);
       return CompletionCheckResult.skipped();
     }
@@ -182,6 +183,17 @@ public static CompletionCheckResult tryCompleteWithPrompt(StringBuilder output,
     return CompletionCheckResult.completed(contentWithoutLastPrompt.substring(promptStartIndex).trim());
   }
 
+  private static boolean shouldSkipCompletion(String completedRegion, String activeCommand, boolean skipCompletion) {
+    if (!skipCompletion) {
+      return false;
+    }
+    String normalizedCommand = normalizeLineEndings(activeCommand == null ? "" : activeCommand).trim();
+    if (normalizedCommand.isBlank()) {
+      return true;
+    }
+    return !normalizeLineEndings(completedRegion).contains(normalizedCommand);
+  }
+
   private static String removeBracketedPasteMarkers(String output) {
     return output.replace(BRACKETED_PASTE_START, "").replace(BRACKETED_PASTE_END, "");
   }

com.microsoft.copilot.eclipse.ui.terminal.tm/src/com/microsoft/copilot/eclipse/ui/terminal/tm/RunInTerminalTool.java

@@ -67,9 +67,7 @@ public class RunInTerminalTool implements IRunInTerminalTool {
 
   // Output and command state
   private StringBuilder sb;
-  private CompletableFuture<String> resultFuture;
-  private volatile String activeCommand;
-  private volatile boolean useMarker;
+  private volatile ForegroundCommand foregroundCommand;
   private volatile boolean skipNextCompletionAfterInterrupt;
 
   /**
@@ -91,22 +89,24 @@ public CompletableFuture<String> executeCommand(String command, boolean isBackgr
       interruptCurrentCommand(COMMAND_INTERRUPTED_MESSAGE, true);
     }
 
-    resultFuture = new CompletableFuture<>();
-    CompletableFuture<String> commandFuture = resultFuture;
-    useMarker = hasShellIntegrationMarker();
-    activeCommand = isBackground ? null : command;
-
-    if (!useMarker) {
-      // Retain only the last line (prompt) in the output buffer
-      if (!sb.isEmpty()) {
-        int lastLineStart = sb.lastIndexOf(StringUtils.LF);
-        if (lastLineStart > 0) {
-          sb.delete(0, lastLineStart);
+    CompletableFuture<String> commandFuture = new CompletableFuture<>();
+    ForegroundCommand commandState = isBackground ? null
+        : new ForegroundCommand(commandFuture, command, hasShellIntegrationMarker());
+
+    if (commandState != null) {
+      foregroundCommand = commandState;
+      if (!commandState.useMarker()) {
+        // Retain only the last line (prompt) in the output buffer
+        if (!sb.isEmpty()) {
+          int lastLineStart = sb.lastIndexOf(StringUtils.LF);
+          if (lastLineStart > 0) {
+            sb.delete(0, lastLineStart);
+          }
         }
+      } else {
+        // For marker-based detection, clear the buffer
+        sb.setLength(0);
       }
-    } else {
-      // For marker-based detection, clear the buffer
-      sb.setLength(0);
     }
 
     String executionId = UUID.randomUUID().toString();
@@ -121,7 +121,7 @@ public CompletableFuture<String> executeCommand(String command, boolean isBackgr
 
       ITerminalService service = TerminalServiceFactory.getService();
       if (service == null) {
-        activeCommand = null;
+        clearForegroundCommand(commandState);
         return CompletableFuture.completedFuture("Failed to open terminal console due to terminal service is null.");
       }
 
@@ -132,7 +132,7 @@ public CompletableFuture<String> executeCommand(String command, boolean isBackgr
           }
           ITerminalViewControl terminalViewControl = finalizeTerminalSetup(executionId, isBackground);
           if (terminalViewControl == null) {
-            activeCommand = null;
+            clearForegroundCommand(commandState);
             commandFuture.complete("Terminal view control cannot be setup for RunInTerminalTool.");
             return;
           }
@@ -143,7 +143,7 @@ public CompletableFuture<String> executeCommand(String command, boolean isBackgr
           }
           sendCommand(terminalViewControl, finalCommand);
         } else {
-          activeCommand = null;
+          clearForegroundCommand(commandState);
           commandFuture.complete("Failed to open terminal console: " + status.getException());
         }
       });
@@ -224,30 +224,37 @@ public void cancelCurrentCommand() {
 
   private void interruptCurrentCommand(String completionMessage, boolean skipInterruptedCompletion) {
     ITerminalViewControl terminalViewControl = null;
-    CompletableFuture<String> commandFuture = null;
+    ForegroundCommand commandState = null;
     synchronized (lock) {
       if (!hasRunningForegroundCommand()) {
         if (!skipInterruptedCompletion) {
           skipNextCompletionAfterInterrupt = false;
         }
         return;
       }
-      activeCommand = null;
+      commandState = foregroundCommand;
+      foregroundCommand = null;
       skipNextCompletionAfterInterrupt = skipInterruptedCompletion;
       terminalViewControl = persistentTerminalViewControl;
-      commandFuture = resultFuture;
     }
 
     if (terminalViewControl != null) {
       sendInterrupt(terminalViewControl);
     }
-    if (commandFuture != null && !commandFuture.isDone()) {
-      commandFuture.complete(completionMessage);
+    if (commandState != null && !commandState.future().isDone()) {
+      commandState.future().complete(completionMessage);
     }
   }
 
   private boolean hasRunningForegroundCommand() {
-    return StringUtils.isNotBlank(activeCommand) && resultFuture != null && !resultFuture.isDone();
+    ForegroundCommand commandState = foregroundCommand;
+    return commandState != null && !commandState.future().isDone();
+  }
+
+  private void clearForegroundCommand(ForegroundCommand commandState) {
+    if (commandState != null && foregroundCommand == commandState) {
+      foregroundCommand = null;
+    }
   }
 
   private void sendInterrupt(ITerminalViewControl terminalViewControl) {
@@ -354,30 +361,35 @@ private ITerminalServiceOutputStreamMonitorListener buildOutputStreamMonitorList
       output.append(content);
 
       // Detect completion based on platform strategy
-      if (!isBackground && resultFuture != null && !resultFuture.isDone()) {
+      ForegroundCommand commandState = foregroundCommand;
+      if (!isBackground && commandState != null && !commandState.future().isDone()) {
         CompletionCheckResult completionResult;
         do {
-          completionResult = useMarker
-              ? TerminalCommandProcessor.tryCompleteWithMarker(output, activeCommand, skipNextCompletionAfterInterrupt)
-              : TerminalCommandProcessor.tryCompleteWithPrompt(output, skipNextCompletionAfterInterrupt);
-          handleCompletionResult(completionResult);
+          completionResult = commandState.useMarker()
+              ? TerminalCommandProcessor.tryCompleteWithMarker(output, commandState.command(),
+                  skipNextCompletionAfterInterrupt)
+              : TerminalCommandProcessor.tryCompleteWithPrompt(output, commandState.command(),
+                  skipNextCompletionAfterInterrupt);
+          handleCompletionResult(commandState, completionResult);
         } while (completionResult.state() == CompletionCheckState.SKIPPED
-            && resultFuture != null && !resultFuture.isDone());
+            && foregroundCommand == commandState && !commandState.future().isDone());
       }
     };
   }
 
-  private void handleCompletionResult(CompletionCheckResult completionResult) {
+  private void handleCompletionResult(ForegroundCommand commandState, CompletionCheckResult completionResult) {
     if (completionResult.state() == CompletionCheckState.INCOMPLETE) {
       return;
     }
     if (completionResult.state() == CompletionCheckState.SKIPPED) {
       skipNextCompletionAfterInterrupt = false;
       return;
     }
-    activeCommand = null;
-    if (resultFuture != null && !resultFuture.isDone()) {
-      resultFuture.complete(completionResult.output());
+    if (foregroundCommand == commandState) {
+      foregroundCommand = null;
+    }
+    if (!commandState.future().isDone()) {
+      commandState.future().complete(completionResult.output());
     }
   }
 
@@ -424,6 +436,9 @@ private String buildBackgroundTerminalTitle(String executionId) {
     return BACKGROUND_TERMINAL_PREFIX + executionId;
   }
 
+  private record ForegroundCommand(CompletableFuture<String> future, String command, boolean useMarker) {
+  }
+
   /**
    * Get active workbench page without UiUtils dependency.
    */