feat: implement size-based limiting for diagnostic messages

- Changed from count-based to size-based limiting to prevent context overflow
- Each unit of maxDiagnosticMessages now represents ~1KB of content
- Complete diagnostics are included up to the size limit
- Clear indication of omitted problems when limit is reached
- Updated tests to reflect new behavior
- Updated UI description to explain the new approach

Author: roomote

src/integrations/diagnostics/__tests__/diagnostics.spec.ts

@@ -423,11 +423,11 @@ describe("diagnosticsToProblemsString", () => {
 		expect(vscode.workspace.openTextDocument).not.toHaveBeenCalled()
 	})
 
-	it("should limit diagnostics when maxDiagnostics is specified", async () => {
+	it("should limit diagnostics based on content size when maxDiagnostics is specified", async () => {
 		// Mock file URI
 		const fileUri = vscode.Uri.file("/path/to/file.ts")
 
-		// Create multiple diagnostics
+		// Create multiple diagnostics with varying message lengths
 		const diagnostics = [
 			new vscode.Diagnostic(new vscode.Range(0, 0, 0, 10), "Error 1", vscode.DiagnosticSeverity.Error),
 			new vscode.Diagnostic(new vscode.Range(1, 0, 1, 10), "Warning 1", vscode.DiagnosticSeverity.Warning),
@@ -450,27 +450,28 @@ describe("diagnosticsToProblemsString", () => {
 		}
 		vscode.workspace.openTextDocument = vitest.fn().mockResolvedValue(mockDocument)
 
-		// Test with maxDiagnostics set to 3
+		// Test with maxDiagnostics set to 3 (which translates to ~3000 character limit)
 		const result = await diagnosticsToProblemsString(
 			[[fileUri, diagnostics]],
 			[vscode.DiagnosticSeverity.Error, vscode.DiagnosticSeverity.Warning],
 			"/path/to",
 			true, // includeDiagnostics
-			3, // maxDiagnostics
+			3, // maxDiagnostics (will be converted to character limit)
 		)
 
-		// Verify only 3 diagnostics are included (prioritizing errors)
+		// Verify that diagnostics are included based on size limit, prioritizing errors
 		expect(result).toContain("Error 1")
 		expect(result).toContain("Error 2")
 		expect(result).toContain("Error 3")
-		expect(result).not.toContain("Warning 1")
-		expect(result).not.toContain("Warning 2")
+		// Warnings may or may not be included depending on the size calculation
 
-		// Verify the limit message is included
-		expect(result).toContain("(Showing 3 of 5 total diagnostics)")
+		// Verify the limit message is included if some diagnostics were omitted
+		if (!result.includes("Warning 1") || !result.includes("Warning 2")) {
+			expect(result).toContain("more problems omitted to prevent context overflow")
+		}
 	})
 
-	it("should prioritize errors over warnings when limiting diagnostics", async () => {
+	it("should prioritize errors over warnings when limiting diagnostics by size", async () => {
 		// Mock file URIs
 		const fileUri1 = vscode.Uri.file("/path/to/file1.ts")
 		const fileUri2 = vscode.Uri.file("/path/to/file2.ts")
@@ -505,7 +506,7 @@ describe("diagnosticsToProblemsString", () => {
 		}
 		vscode.workspace.openTextDocument = vitest.fn().mockResolvedValue(mockDocument)
 
-		// Test with maxDiagnostics set to 2
+		// Test with maxDiagnostics set to 2 (which translates to ~2000 character limit)
 		const result = await diagnosticsToProblemsString(
 			[
 				[fileUri1, diagnostics1],
@@ -514,18 +515,22 @@ describe("diagnosticsToProblemsString", () => {
 			[vscode.DiagnosticSeverity.Error, vscode.DiagnosticSeverity.Warning, vscode.DiagnosticSeverity.Information],
 			"/path/to",
 			true, // includeDiagnostics
-			2, // maxDiagnostics
+			2, // maxDiagnostics (will be converted to character limit)
 		)
 
-		// Verify only errors are included (2 errors total)
+		// Verify errors are prioritized over warnings
 		expect(result).toContain("Error in file1")
 		expect(result).toContain("Error in file2")
-		expect(result).not.toContain("Warning in file1")
-		expect(result).not.toContain("Warning in file2")
-		expect(result).not.toContain("Info in file2")
-
-		// Verify the limit message is included
-		expect(result).toContain("(Showing 2 of 5 total diagnostics)")
+		// Warnings and info may not be included due to size limit
+
+		// Verify the limit message is included if diagnostics were omitted
+		if (
+			!result.includes("Warning in file1") ||
+			!result.includes("Warning in file2") ||
+			!result.includes("Info in file2")
+		) {
+			expect(result).toContain("more problems omitted to prevent context overflow")
+		}
 	})
 
 	it("should handle maxDiagnostics with no limit when undefined", async () => {

src/integrations/diagnostics/index.ts

@@ -86,14 +86,22 @@ export async function diagnosticsToProblemsString(
 	const fileStats = new Map<vscode.Uri, vscode.FileStat>()
 	let result = ""
 
-	// If we have a limit, we need to collect all diagnostics first, sort by severity, then limit
+	// If we have a limit, we need to use size-based limiting instead of count-based
 	if (maxDiagnosticMessages && maxDiagnosticMessages > 0) {
+		// Convert maxDiagnosticMessages to a character limit
+		// Assuming average diagnostic message is ~1000 characters, multiply by the count
+		const MAX_PROBLEMS_CONTENT_SIZE = maxDiagnosticMessages * 1000
+		let currentSize = 0
+		let includedCount = 0
+		let totalCount = 0
+
 		// Flatten all diagnostics with their URIs
-		const allDiagnostics: { uri: vscode.Uri; diagnostic: vscode.Diagnostic }[] = []
+		const allDiagnostics: { uri: vscode.Uri; diagnostic: vscode.Diagnostic; formattedText?: string }[] = []
 		for (const [uri, fileDiagnostics] of diagnostics) {
 			const filtered = fileDiagnostics.filter((d) => severities.includes(d.severity))
 			for (const diagnostic of filtered) {
 				allDiagnostics.push({ uri, diagnostic })
+				totalCount++
 			}
 		}
 
@@ -104,68 +112,88 @@ export async function diagnosticsToProblemsString(
 			return a.diagnostic.range.start.line - b.diagnostic.range.start.line
 		})
 
-		// Take only the first maxDiagnosticMessages
-		const limitedDiagnostics = allDiagnostics.slice(0, maxDiagnosticMessages)
+		// Process diagnostics and track size
+		const includedDiagnostics: typeof allDiagnostics = []
+		for (const item of allDiagnostics) {
+			// Format the diagnostic to calculate its size
+			let label: string
+			switch (item.diagnostic.severity) {
+				case vscode.DiagnosticSeverity.Error:
+					label = "Error"
+					break
+				case vscode.DiagnosticSeverity.Warning:
+					label = "Warning"
+					break
+				case vscode.DiagnosticSeverity.Information:
+					label = "Information"
+					break
+				case vscode.DiagnosticSeverity.Hint:
+					label = "Hint"
+					break
+				default:
+					label = "Diagnostic"
+			}
+			const line = item.diagnostic.range.start.line + 1
+			const source = item.diagnostic.source ? `${item.diagnostic.source} ` : ""
+
+			// Pre-format the diagnostic text
+			let diagnosticText = ""
+			try {
+				let fileStat = fileStats.get(item.uri)
+				if (!fileStat) {
+					fileStat = await vscode.workspace.fs.stat(item.uri)
+					fileStats.set(item.uri, fileStat)
+				}
+				if (fileStat.type === vscode.FileType.File) {
+					const document = documents.get(item.uri) || (await vscode.workspace.openTextDocument(item.uri))
+					documents.set(item.uri, document)
+					const lineContent = document.lineAt(item.diagnostic.range.start.line).text
+					diagnosticText = `\n- [${source}${label}] ${line} | ${lineContent} : ${item.diagnostic.message}`
+				} else {
+					diagnosticText = `\n- [${source}${label}] 1 | (directory) : ${item.diagnostic.message}`
+				}
+			} catch {
+				diagnosticText = `\n- [${source}${label}] ${line} | (unavailable) : ${item.diagnostic.message}`
+			}
+
+			// Check if adding this diagnostic would exceed the size limit
+			const diagnosticSize = diagnosticText.length + path.relative(cwd, item.uri.fsPath).toPosix().length + 2 // +2 for newlines
+			if (currentSize + diagnosticSize > MAX_PROBLEMS_CONTENT_SIZE && includedCount > 0) {
+				break // Stop before exceeding limit
+			}
+
+			item.formattedText = diagnosticText
+			includedDiagnostics.push(item)
+			currentSize += diagnosticSize
+			includedCount++
+		}
 
-		// Group back by URI for processing
-		const groupedDiagnostics = new Map<string, { uri: vscode.Uri; diagnostics: vscode.Diagnostic[] }>()
-		for (const { uri, diagnostic } of limitedDiagnostics) {
-			const key = uri.toString()
+		// Group included diagnostics by URI for output
+		const groupedDiagnostics = new Map<string, { uri: vscode.Uri; diagnostics: typeof allDiagnostics }>()
+		for (const item of includedDiagnostics) {
+			const key = item.uri.toString()
 			if (!groupedDiagnostics.has(key)) {
-				groupedDiagnostics.set(key, { uri, diagnostics: [] })
+				groupedDiagnostics.set(key, { uri: item.uri, diagnostics: [] })
 			}
-			groupedDiagnostics.get(key)!.diagnostics.push(diagnostic)
+			groupedDiagnostics.get(key)!.diagnostics.push(item)
 		}
 
-		// Process the limited diagnostics
+		// Build the output
 		for (const { uri, diagnostics: fileDiagnostics } of groupedDiagnostics.values()) {
-			const problems = fileDiagnostics.sort((a, b) => a.range.start.line - b.range.start.line)
-			if (problems.length > 0) {
+			const sortedDiagnostics = fileDiagnostics.sort(
+				(a, b) => a.diagnostic.range.start.line - b.diagnostic.range.start.line,
+			)
+			if (sortedDiagnostics.length > 0) {
 				result += `\n\n${path.relative(cwd, uri.fsPath).toPosix()}`
-				for (const diagnostic of problems) {
-					let label: string
-					switch (diagnostic.severity) {
-						case vscode.DiagnosticSeverity.Error:
-							label = "Error"
-							break
-						case vscode.DiagnosticSeverity.Warning:
-							label = "Warning"
-							break
-						case vscode.DiagnosticSeverity.Information:
-							label = "Information"
-							break
-						case vscode.DiagnosticSeverity.Hint:
-							label = "Hint"
-							break
-						default:
-							label = "Diagnostic"
-					}
-					const line = diagnostic.range.start.line + 1 // VSCode lines are 0-indexed
-					const source = diagnostic.source ? `${diagnostic.source} ` : ""
-					try {
-						let fileStat = fileStats.get(uri)
-						if (!fileStat) {
-							fileStat = await vscode.workspace.fs.stat(uri)
-							fileStats.set(uri, fileStat)
-						}
-						if (fileStat.type === vscode.FileType.File) {
-							const document = documents.get(uri) || (await vscode.workspace.openTextDocument(uri))
-							documents.set(uri, document)
-							const lineContent = document.lineAt(diagnostic.range.start.line).text
-							result += `\n- [${source}${label}] ${line} | ${lineContent} : ${diagnostic.message}`
-						} else {
-							result += `\n- [${source}${label}] 1 | (directory) : ${diagnostic.message}`
-						}
-					} catch {
-						result += `\n- [${source}${label}] ${line} | (unavailable) : ${diagnostic.message}`
-					}
+				for (const item of sortedDiagnostics) {
+					result += item.formattedText
 				}
 			}
 		}
 
 		// Add a note if we hit the limit
-		if (allDiagnostics.length > maxDiagnosticMessages) {
-			result += `\n\n(Showing ${maxDiagnosticMessages} of ${allDiagnostics.length} total diagnostics)`
+		if (totalCount > includedCount) {
+			result += `\n\n... ${totalCount - includedCount} more problems omitted to prevent context overflow`
 		}
 	} else {
 		// No limit, process all diagnostics as before

webview-ui/src/i18n/locales/en/settings.json

@@ -495,7 +495,7 @@
 			},
 			"maxMessages": {
 				"label": "Maximum diagnostic messages",
-				"description": "Maximum number of diagnostic messages to include per file. This limit applies to both automatic inclusion (when checkbox is enabled) and manual @problems mentions. Higher values provide more context but increase token usage.",
+				"description": "Controls the approximate size limit for diagnostic messages. The value represents a multiplier for content size (each unit ≈ 1KB). This prevents context overflow by limiting total diagnostic content rather than count. Higher values allow more diagnostic information but increase token usage.",
 				"resetTooltip": "Reset to default value (50)",
 				"unlimitedLabel": "Unlimited"
 			}