back out non-file related checks

Author: ocasta181

src/core/Cline.ts

@@ -1140,9 +1140,9 @@ export class Cline {
 		const contextWindow = this.api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
 		const maxAllowedSize = getMaxAllowedSize(contextWindow)
 
-		const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd, contextWindow)
+		const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd)
 		terminalInfo.terminal.show() // weird visual bug when creating new terminals (even manually) where there's an empty space at the top.
-		const process = this.terminalManager.runCommand(terminalInfo, command, maxAllowedSize)
+		const process = this.terminalManager.runCommand(terminalInfo, command)
 
 		let userFeedback: { text?: string; images?: string[] } | undefined
 		let didContinue = false
@@ -1188,7 +1188,7 @@ export class Cline {
 		// the correct order of messages (although the webview is smart about
 		// grouping command_output messages despite any gaps anyways)
 		await delay(50)
-		// AKF TODO -> investigate failed results
+
 		result = result.trim()
 
 		if (userFeedback) {
@@ -2963,16 +2963,6 @@ export class Cline {
 			throw new Error("Cline instance aborted")
 		}
 
-		// Log file content being passed to model
-		userContent.forEach((block) => {
-			if (block.type === "text" && block.text) {
-				// Look for file content markers
-				if (block.text.includes("<file_content") || block.text.includes("<final_file_content")) {
-					console.log(`[MODEL_INPUT] File content being passed to model. Content length: ${block.text.length} chars`)
-				}
-			}
-		})
-
 		if (this.consecutiveMistakeCount >= 3) {
 			if (this.autoApprovalSettings.enabled && this.autoApprovalSettings.enableNotifications) {
 				showSystemNotification({
@@ -3442,44 +3432,34 @@ export class Cline {
 		if (busyTerminals.length > 0) {
 			// terminals are cool, let's retrieve their output
 			terminalDetails += "\n\n# Actively Running Terminals"
-			const contextWindow = this.api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
-
-			// Get output from all busy terminals
-			const busyOutputs = await Promise.all(
-				busyTerminals.map(async (terminal) => {
-					const output = await this.terminalManager.getUnretrievedOutput(terminal.id, contextWindow)
-					return { terminal, output }
-				}),
-			)
-
-			// Add output to details
-			for (const { terminal, output } of busyOutputs) {
-				terminalDetails += `\n## Original command: \`${terminal.lastCommand}\``
-				if (output) {
-					terminalDetails += `\n### New Output\n${output}`
+			for (const busyTerminal of busyTerminals) {
+				terminalDetails += `\n## Original command: \`${busyTerminal.lastCommand}\``
+				const newOutput = this.terminalManager.getUnretrievedOutput(busyTerminal.id)
+				if (newOutput) {
+					terminalDetails += `\n### New Output\n${newOutput}`
+				} else {
+					// details += `\n(Still running, no new output)` // don't want to show this right after running the command
 				}
 			}
 		}
 
 		// only show inactive terminals if there's output to show
 		if (inactiveTerminals.length > 0) {
-			const contextWindow = this.api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
-
-			// Get output from all inactive terminals
-			const inactiveOutputs = await Promise.all(
-				inactiveTerminals.map(async (terminal) => {
-					const output = await this.terminalManager.getUnretrievedOutput(terminal.id, contextWindow)
-					return { terminal, output }
-				}),
-			)
-
-			// Filter and add outputs that have content
-			const outputsWithContent = inactiveOutputs.filter(({ output }) => output)
-			if (outputsWithContent.length > 0) {
+			const inactiveTerminalOutputs = new Map<number, string>()
+			for (const inactiveTerminal of inactiveTerminals) {
+				const newOutput = await this.terminalManager.getUnretrievedOutput(inactiveTerminal.id)
+				if (newOutput) {
+					inactiveTerminalOutputs.set(inactiveTerminal.id, newOutput)
+				}
+			}
+			if (inactiveTerminalOutputs.size > 0) {
 				terminalDetails += "\n\n# Inactive Terminals"
-				for (const { terminal, output } of outputsWithContent) {
-					terminalDetails += `\n## ${terminal.lastCommand}`
-					terminalDetails += `\n### New Output\n${output}`
+				for (const [terminalId, newOutput] of inactiveTerminalOutputs) {
+					const inactiveTerminal = inactiveTerminals.find((t) => t.id === terminalId)
+					if (inactiveTerminal) {
+						terminalDetails += `\n## ${inactiveTerminal.lastCommand}`
+						terminalDetails += `\n### New Output\n${newOutput}`
+					}
 				}
 			}
 		}

src/core/mentions/index.ts

@@ -117,8 +117,7 @@ export async function parseMentions(
 			}
 		} else if (mention === "terminal") {
 			try {
-				const contextWindow = api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
-				const terminalOutput = await getLatestTerminalOutput(contextWindow)
+				const terminalOutput = await getLatestTerminalOutput()
 				parsedText += `\n\n<terminal_output>\n${terminalOutput}\n</terminal_output>`
 			} catch (error) {
 				parsedText += `\n\n<terminal_output>\nError fetching terminal output: ${error.message}\n</terminal_output>`

src/integrations/misc/extract-text.ts

@@ -16,20 +16,20 @@ import { ContentTooLargeError } from "../../shared/errors"
  * @throws ContentTooLargeError if content exceeds size limit
  */
 export async function extractTextFromTerminal(content: string | Buffer, contextWindow: number, command: string): Promise<string> {
-	console.log(`[TERMINAL_SIZE_CHECK] Checking size for command output: ${command}`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Checking size for command output: ${command}`)
 
 	// Convert to string but don't trim yet
 	const rawContent = content.toString()
-	console.log(`[TERMINAL_SIZE_CHECK] Raw content length: ${rawContent.length}`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Raw content length: ${rawContent.length}`)
 
 	// Check size before trimming
 	const sizeEstimate = estimateContentSize(rawContent, contextWindow)
-	console.log(`[TERMINAL_SIZE_CHECK] Content size: ${sizeEstimate.bytes} bytes`)
-	console.log(`[TERMINAL_SIZE_CHECK] Estimated tokens: ${sizeEstimate.estimatedTokens}`)
-	console.log(`[TERMINAL_SIZE_CHECK] Context window: ${contextWindow}`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Content size: ${sizeEstimate.bytes} bytes`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Estimated tokens: ${sizeEstimate.estimatedTokens}`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Context window: ${contextWindow}`)
 
 	if (sizeEstimate.wouldExceedLimit) {
-		console.log(`[TERMINAL_SIZE_CHECK] Output exceeds size limit`)
+		console.debug(`[TERMINAL_SIZE_CHECK] Output exceeds size limit`)
 		throw new ContentTooLargeError({
 			type: "terminal",
 			command,
@@ -39,8 +39,8 @@ export async function extractTextFromTerminal(content: string | Buffer, contextW
 
 	// Only trim after size check passes
 	const cleanContent = rawContent.trim()
-	console.log(`[TERMINAL_SIZE_CHECK] Clean content length: ${cleanContent.length}`)
-	console.log(`[TERMINAL_SIZE_CHECK] Size check passed`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Clean content length: ${cleanContent.length}`)
+	console.debug(`[TERMINAL_SIZE_CHECK] Size check passed`)
 	return cleanContent
 }
 
@@ -51,20 +51,20 @@ export async function extractTextFromFile(filePath: string, contextWindow: numbe
 		throw new Error(`File not found: ${filePath}`)
 	}
 
-	console.log(`[FILE_READ_CHECK] Checking size for file: ${filePath}`)
+	console.debug(`[FILE_READ_CHECK] Checking size for file: ${filePath}`)
 
 	// Get file stats to check size
 	const stats = await fs.stat(filePath)
-	console.log(`[FILE_SIZE_CHECK] File size: ${stats.size} bytes`)
+	console.debug(`[FILE_SIZE_CHECK] File size: ${stats.size} bytes`)
 
 	// Calculate max allowed size from context window
 	const maxAllowedSize = getMaxAllowedSize(contextWindow)
-	console.log(`[FILE_SIZE_CHECK] Max allowed size: ${maxAllowedSize} tokens`)
+	console.debug(`[FILE_SIZE_CHECK] Max allowed size: ${maxAllowedSize} tokens`)
 
 	// Check if file size would exceed limit before attempting to read
 	// This is more efficient than creating a full SizeEstimate object when we just need a boolean check
 	if (wouldExceedSizeLimit(stats.size, contextWindow)) {
-		console.log(`[FILE_SIZE_CHECK] File exceeds size limit`)
+		console.debug(`[FILE_SIZE_CHECK] File exceeds size limit`)
 		// Only create the full size estimate when we need it for the error
 		const sizeEstimate = await estimateFileSize(filePath, maxAllowedSize)
 		throw new ContentTooLargeError({
@@ -73,9 +73,9 @@ export async function extractTextFromFile(filePath: string, contextWindow: numbe
 			size: sizeEstimate,
 		})
 	}
-	console.log(`[FILE_SIZE_CHECK] File size check passed`)
+	console.debug(`[FILE_SIZE_CHECK] File size check passed`)
 	const fileExtension = path.extname(filePath).toLowerCase()
-	console.log(`[FILE_READ] Reading file: ${filePath}`)
+	console.debug(`[FILE_READ] Reading file: ${filePath}`)
 	let content: string
 	switch (fileExtension) {
 		case ".pdf":
@@ -95,7 +95,7 @@ export async function extractTextFromFile(filePath: string, contextWindow: numbe
 				throw new Error(`Cannot read text for file type: ${fileExtension}`)
 			}
 	}
-	console.log(`[FILE_READ_COMPLETE] File read complete. Content length: ${content.length} chars`)
+	console.debug(`[FILE_READ_COMPLETE] File read complete. Content length: ${content.length} chars`)
 	return content
 }
 

src/integrations/terminal/TerminalManager.ts

@@ -3,7 +3,6 @@ import * as vscode from "vscode"
 import { arePathsEqual } from "../../utils/path"
 import { mergePromise, TerminalProcess, TerminalProcessResultPromise } from "./TerminalProcess"
 import { TerminalInfo, TerminalRegistry } from "./TerminalRegistry"
-import { extractTextFromTerminal } from "../../integrations/misc/extract-text"
 
 /*
 TerminalManager:
@@ -110,7 +109,7 @@ export class TerminalManager {
 		}
 	}
 
-	runCommand(terminalInfo: TerminalInfo, command: string, contextLimit: number): TerminalProcessResultPromise {
+	runCommand(terminalInfo: TerminalInfo, command: string): TerminalProcessResultPromise {
 		terminalInfo.busy = true
 		terminalInfo.lastCommand = command
 		const process = new TerminalProcess()
@@ -142,22 +141,22 @@ export class TerminalManager {
 		// if shell integration is already active, run the command immediately
 		if (terminalInfo.terminal.shellIntegration) {
 			process.waitForShellIntegration = false
-			process.run(terminalInfo.terminal, command, contextLimit)
+			process.run(terminalInfo.terminal, command)
 		} else {
 			// docs recommend waiting 3s for shell integration to activate
 			pWaitFor(() => terminalInfo.terminal.shellIntegration !== undefined, { timeout: 4000 }).finally(() => {
 				const existingProcess = this.processes.get(terminalInfo.id)
 				if (existingProcess && existingProcess.waitForShellIntegration) {
 					existingProcess.waitForShellIntegration = false
-					existingProcess.run(terminalInfo.terminal, command, contextLimit)
+					existingProcess.run(terminalInfo.terminal, command)
 				}
 			})
 		}
 
 		return mergePromise(process, promise)
 	}
 
-	async getOrCreateTerminal(cwd: string, contextLimit: number): Promise<TerminalInfo> {
+	async getOrCreateTerminal(cwd: string): Promise<TerminalInfo> {
 		const terminals = TerminalRegistry.getAllTerminals()
 
 		// Find available terminal from our pool first (created for this task)
@@ -180,7 +179,7 @@ export class TerminalManager {
 		const availableTerminal = terminals.find((t) => !t.busy)
 		if (availableTerminal) {
 			// Navigate back to the desired directory
-			await this.runCommand(availableTerminal, `cd "${cwd}"`, contextLimit)
+			await this.runCommand(availableTerminal, `cd "${cwd}"`)
 			this.terminalIds.add(availableTerminal.id)
 			return availableTerminal
 		}
@@ -198,19 +197,12 @@ export class TerminalManager {
 			.map((t) => ({ id: t.id, lastCommand: t.lastCommand }))
 	}
 
-	async getUnretrievedOutput(terminalId: number, contextLimit: number): Promise<string> {
+	getUnretrievedOutput(terminalId: number): string {
 		if (!this.terminalIds.has(terminalId)) {
 			return ""
 		}
 		const process = this.processes.get(terminalId)
-		if (!process) {
-			return ""
-		}
-		const output = process.getUnretrievedOutput()
-		if (!output) {
-			return ""
-		}
-		return await extractTextFromTerminal(output, contextLimit, `Terminal ${terminalId} output`)
+		return process ? process.getUnretrievedOutput() : ""
 	}
 
 	isProcessHot(terminalId: number): boolean {