Improve logging, only check cursor line

Author: Tyriar

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/executeStrategy.ts

@@ -36,77 +36,77 @@ export async function waitForIdle(onData: Event<unknown>, idleDurationMs: number
 	return deferred.p.finally(() => store.dispose());
 }
 
+export interface IPromptDetectionResult {
+	/**
+	 * Whether a prompt was detected.
+	 */
+	detected: boolean;
+	/**
+	 * The reason for logging.
+	 */
+	reason?: string;
+}
+
 /**
  * Detects if the given text content appears to end with a common prompt pattern.
  * This is used as a heuristic to determine if a command has finished executing.
- * 
+ *
  * The idea is to do basic regex checks after the initial timeout to extend the
  * timeout if it doesn't look like a common prompt format, giving commands more
  * time to complete before assuming they're done.
  */
-export function detectsCommonPromptPattern(content: string): boolean {
-	if (!content || content.trim().length === 0) {
-		return false;
-	}
-
-	// Split content into lines and check the last non-empty line
-	const lines = content.split('\n');
-	let lastLine = '';
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i].trim();
-		if (line.length > 0) {
-			lastLine = line;
-			break;
-		}
+export function detectsCommonPromptPattern(cursorLine: string): IPromptDetectionResult {
+	if (!cursorLine || cursorLine.trim().length === 0) {
+		return { detected: false, reason: 'Content is empty or contains only whitespace' };
 	}
 
-	if (!lastLine) {
-		return false;
+	if (!cursorLine) {
+		return { detected: false, reason: 'No non-empty lines found' };
 	}
 
 	// PowerShell prompt: PS C:\> or similar patterns
-	if (/PS\s+[A-Z]:\\.*>\s*$/.test(lastLine)) {
-		return true;
+	if (/PS\s+[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `PowerShell prompt pattern detected: "${cursorLine}"` };
 	}
 
 	// Command Prompt: C:\path>
-	if (/^[A-Z]:\\.*>\s*$/.test(lastLine)) {
-		return true;
+	if (/^[A-Z]:\\.*>\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Command Prompt pattern detected: "${cursorLine}"` };
 	}
 
-	// Bash-style prompts ending with $ 
-	if (/\$\s*$/.test(lastLine)) {
-		return true;
+	// Bash-style prompts ending with $
+	if (/\$\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Bash-style prompt pattern detected: "${cursorLine}"` };
 	}
 
 	// Root prompts ending with #
-	if (/#\s*$/.test(lastLine)) {
-		return true;
+	if (/#\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Root prompt pattern detected: "${cursorLine}"` };
 	}
 
 	// Python REPL prompt
-	if (/^>>>\s*$/.test(lastLine)) {
-		return true;
+	if (/^>>>\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Python REPL prompt pattern detected: "${cursorLine}"` };
 	}
 
-	// Custom prompts ending with the starship character ❯ (\u276f)
-	if (/\u276f\s*$/.test(lastLine)) {
-		return true;
+	// Custom prompts ending with the starship character (\u276f)
+	if (/\u276f\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Starship prompt pattern detected: "${cursorLine}"` };
 	}
 
 	// Generic prompts ending with common prompt characters
-	if (/[>%]\s*$/.test(lastLine)) {
-		return true;
+	if (/[>%]\s*$/.test(cursorLine)) {
+		return { detected: true, reason: `Generic prompt pattern detected: "${cursorLine}"` };
 	}
 
-	return false;
+	return { detected: false, reason: `No common prompt pattern found in last line: "${cursorLine}"` };
 }
 
 /**
  * Enhanced version of waitForIdle that uses prompt detection heuristics.
  * After the initial timeout, checks if the terminal content looks like a common prompt.
  * If not, extends the timeout to give the command more time to complete.
- * 
+ *
  * This addresses the need for better heuristics around prompt characters for evaluating
  * no shell integration command finished state, as requested in the issue.
  */
@@ -115,44 +115,36 @@ export async function waitForIdleWithPromptHeuristics(
 	instance: ITerminalInstance,
 	initialTimeoutMs: number,
 	extendedTimeoutMs: number = 2000
-): Promise<void> {
-	// First, wait for the initial timeout period
+): Promise<IPromptDetectionResult> {
 	await waitForIdle(onData, initialTimeoutMs);
 
-	// Get the current terminal content to check for prompt patterns
 	try {
 		const xterm = await instance.xtermReadyPromise;
 		if (xterm) {
-			// Get the current visible content from the terminal
-			const buffer = xterm.raw.buffer.active;
 			let content = '';
-			
-			// Read the current line and a few lines above to detect prompt patterns
-			// Focus on the area around the cursor, which is most likely to contain the prompt
-			const currentLine = buffer.baseY + buffer.cursorY;
-			const startLine = Math.max(0, currentLine - 2); // Read up to 2 lines above
-			const endLine = Math.min(buffer.length, currentLine + 1); // Read current line
-			
-			for (let i = startLine; i < endLine; i++) {
-				const line = buffer.getLine(i);
-				if (line) {
-					content += line.translateToString(true) + '\n';
-				}
+			const buffer = xterm.raw.buffer.active;
+			const line = buffer.getLine(buffer.baseY + buffer.cursorY);
+			if (line) {
+				content = line.translateToString(true) + '\n';
 			}
 
 			// If we detect a common prompt pattern, we're done
-			// Note: Logging is handled by the calling strategy (e.g., noneExecuteStrategy)
-			if (detectsCommonPromptPattern(content)) {
-				return;
+			const promptResult = detectsCommonPromptPattern(content);
+			if (promptResult.detected) {
+				return promptResult;
 			}
 
 			// Otherwise, wait for the extended timeout period
 			await waitForIdle(onData, extendedTimeoutMs);
+			return { detected: false, reason: 'Extended timeout reached without prompt detection' };
 		}
 	} catch (error) {
 		// If there's an error getting terminal content, fall back to extended timeout
 		await waitForIdle(onData, extendedTimeoutMs);
+		return { detected: false, reason: `Error reading terminal content: ${error}` };
 	}
+
+	return { detected: false, reason: 'Xterm not available' };
 }
 
 /**

src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/executeStrategy/noneExecuteStrategy.ts

@@ -64,7 +64,8 @@ export class NoneExecuteStrategy implements ITerminalExecuteStrategy {
 
 			// Assume the command is done when it's idle
 			this._log('Waiting for idle with prompt heuristics');
-			await waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000);
+			const promptResult = await waitForIdleWithPromptHeuristics(this._instance.onData, this._instance, 1000, 10000);
+			this._log(`Prompt detection result: ${promptResult.detected ? 'detected' : 'not detected'} - ${promptResult.reason}`);
 			if (token.isCancellationRequested) {
 				throw new CancellationError();
 			}