current progress

Author: ocasta181

package-lock.json

@@ -1140,7 +1140,7 @@ 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)
+		const terminalInfo = await this.terminalManager.getOrCreateTerminal(cwd, contextWindow)
 		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)
 
@@ -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) {
@@ -1314,10 +1314,6 @@ export class Cline {
 				const { tokensIn, tokensOut, cacheWrites, cacheReads }: ClineApiReqInfo = JSON.parse(previousRequest.text)
 				const totalTokens = (tokensIn || 0) + (tokensOut || 0) + (cacheWrites || 0) + (cacheReads || 0)
 				let contextWindow = this.api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
-				// FIXME: hack to get anyone using openai compatible with deepseek to have the proper context window instead of the default 128k. We need a way for the user to specify the context window for models they input through openai compatible
-				if (this.api instanceof OpenAiHandler && this.api.getModel().id.toLowerCase().includes("deepseek")) {
-					contextWindow = 64_000
-				}
 				const maxAllowedSize = getMaxAllowedSize(contextWindow)
 
 				// This is the most reliable way to know when we're close to hitting the context window.
@@ -1964,17 +1960,15 @@ export class Cline {
 								}
 								// Get context window and used context from API model
 								const contextWindow = this.api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
-								const maxAllowedSize = getMaxAllowedSize(contextWindow)
 
-								// now execute the tool like normal
-								const content = await extractTextFromFile(absolutePath, maxAllowedSize)
+								// Pass the raw context window size - extractTextFromFile will calculate the appropriate limit
+								const content = await extractTextFromFile(absolutePath, contextWindow)
 								pushToolResult(content)
 
 								break
 							}
 						} catch (error) {
 							await handleError("reading file", error)
-
 							break
 						}
 					}
@@ -2969,6 +2963,16 @@ 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({
@@ -3438,33 +3442,44 @@ export class Cline {
 		if (busyTerminals.length > 0) {
 			// terminals are cool, let's retrieve their output
 			terminalDetails += "\n\n# Actively Running Terminals"
-			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
+			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}`
 				}
 			}
 		}
+
 		// only show inactive terminals if there's output to show
 		if (inactiveTerminals.length > 0) {
-			const inactiveTerminalOutputs = new Map<number, string>()
-			for (const inactiveTerminal of inactiveTerminals) {
-				const newOutput = this.terminalManager.getUnretrievedOutput(inactiveTerminal.id)
-				if (newOutput) {
-					inactiveTerminalOutputs.set(inactiveTerminal.id, newOutput)
-				}
-			}
-			if (inactiveTerminalOutputs.size > 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) {
 				terminalDetails += "\n\n# Inactive Terminals"
-				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}`
-					}
+				for (const { terminal, output } of outputsWithContent) {
+					terminalDetails += `\n## ${terminal.lastCommand}`
+					terminalDetails += `\n### New Output\n${output}`
 				}
 			}
 		}

src/core/Cline.ts

@@ -117,7 +117,8 @@ export async function parseMentions(
 			}
 		} else if (mention === "terminal") {
 			try {
-				const terminalOutput = await getLatestTerminalOutput()
+				const contextWindow = api.getModel().info.contextWindow || 64_000 // minimum context (Deepseek)
+				const terminalOutput = await getLatestTerminalOutput(contextWindow)
 				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/core/mentions/index.ts

@@ -4,46 +4,99 @@ import pdf from "pdf-parse/lib/pdf-parse"
 import mammoth from "mammoth"
 import fs from "fs/promises"
 import { isBinaryFile } from "isbinaryfile"
-import { estimateFileSize, wouldExceedSizeLimit } from "../../utils/content-size"
+import { estimateContentSize, estimateFileSize, wouldExceedSizeLimit, getMaxAllowedSize } from "../../utils/content-size"
 import { ContentTooLargeError } from "../../shared/errors"
 
-export async function extractTextFromFile(filePath: string, contextLimit: number): Promise<string> {
+/**
+ * Checks if terminal output would exceed size limits and returns the content if safe
+ * @param content The terminal output content to check
+ * @param contextWindow Context window limit in tokens
+ * @param command The command that generated this output (for error reporting)
+ * @returns The validated content
+ * @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}`)
+
+	// Convert to string but don't trim yet
+	const rawContent = content.toString()
+	console.log(`[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}`)
+
+	if (sizeEstimate.wouldExceedLimit) {
+		console.log(`[TERMINAL_SIZE_CHECK] Output exceeds size limit`)
+		throw new ContentTooLargeError({
+			type: "terminal",
+			command,
+			size: sizeEstimate,
+		})
+	}
+
+	// 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`)
+	return cleanContent
+}
+
+export async function extractTextFromFile(filePath: string, contextWindow: number): Promise<string> {
 	try {
 		await fs.access(filePath)
 	} catch (error) {
 		throw new Error(`File not found: ${filePath}`)
 	}
 
+	console.log(`[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`)
+
+	// Calculate max allowed size from context window
+	const maxAllowedSize = getMaxAllowedSize(contextWindow)
+	console.log(`[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, contextLimit)) {
+	if (wouldExceedSizeLimit(stats.size, contextWindow)) {
+		console.log(`[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, contextLimit)
+		const sizeEstimate = await estimateFileSize(filePath, maxAllowedSize)
 		throw new ContentTooLargeError({
 			type: "file",
 			path: filePath,
 			size: sizeEstimate,
 		})
 	}
+	console.log(`[FILE_SIZE_CHECK] File size check passed`)
 	const fileExtension = path.extname(filePath).toLowerCase()
+	console.log(`[FILE_READ] Reading file: ${filePath}`)
+	let content: string
 	switch (fileExtension) {
 		case ".pdf":
-			return extractTextFromPDF(filePath)
+			content = await extractTextFromPDF(filePath)
+			break
 		case ".docx":
-			return extractTextFromDOCX(filePath)
+			content = await extractTextFromDOCX(filePath)
+			break
 		case ".ipynb":
-			return extractTextFromIPYNB(filePath)
+			content = await extractTextFromIPYNB(filePath)
+			break
 		default:
 			const isBinary = await isBinaryFile(filePath).catch(() => false)
 			if (!isBinary) {
-				return await fs.readFile(filePath, "utf8")
+				content = await fs.readFile(filePath, "utf8")
 			} else {
 				throw new Error(`Cannot read text for file type: ${fileExtension}`)
 			}
 	}
+	console.log(`[FILE_READ_COMPLETE] File read complete. Content length: ${content.length} chars`)
+	return content
 }
 
 async function extractTextFromPDF(filePath: string): Promise<string> {

src/integrations/misc/extract-text.ts

@@ -3,6 +3,7 @@ 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:
@@ -109,7 +110,7 @@ export class TerminalManager {
 		}
 	}
 
-	runCommand(terminalInfo: TerminalInfo, command: string, contextLimit?: number): TerminalProcessResultPromise {
+	runCommand(terminalInfo: TerminalInfo, command: string, contextLimit: number): TerminalProcessResultPromise {
 		terminalInfo.busy = true
 		terminalInfo.lastCommand = command
 		const process = new TerminalProcess()
@@ -156,7 +157,7 @@ export class TerminalManager {
 		return mergePromise(process, promise)
 	}
 
-	async getOrCreateTerminal(cwd: string): Promise<TerminalInfo> {
+	async getOrCreateTerminal(cwd: string, contextLimit: number): Promise<TerminalInfo> {
 		const terminals = TerminalRegistry.getAllTerminals()
 
 		// Find available terminal from our pool first (created for this task)
@@ -179,7 +180,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}"`)
+			await this.runCommand(availableTerminal, `cd "${cwd}"`, contextLimit)
 			this.terminalIds.add(availableTerminal.id)
 			return availableTerminal
 		}
@@ -197,12 +198,19 @@ export class TerminalManager {
 			.map((t) => ({ id: t.id, lastCommand: t.lastCommand }))
 	}
 
-	getUnretrievedOutput(terminalId: number): string {
+	async getUnretrievedOutput(terminalId: number, contextLimit: number): Promise<string> {
 		if (!this.terminalIds.has(terminalId)) {
 			return ""
 		}
 		const process = this.processes.get(terminalId)
-		return process ? process.getUnretrievedOutput() : ""
+		if (!process) {
+			return ""
+		}
+		const output = process.getUnretrievedOutput()
+		if (!output) {
+			return ""
+		}
+		return await extractTextFromTerminal(output, contextLimit, `Terminal ${terminalId} output`)
 	}
 
 	isProcessHot(terminalId: number): boolean {