fix: improve XML parsing error handling for apply_diff tool

src/core/tools/multiApplyDiffTool.ts

@@ -150,7 +150,38 @@ export async function applyDiffTool(
 			}
 		} catch (error) {
 			const errorMessage = error instanceof Error ? error.message : String(error)
-			const detailedError = `Failed to parse apply_diff XML. This usually means:
+
+			// Check if this is the specific "StopNode is not closed" error
+			const isStopNodeError = errorMessage.includes("StopNode is not closed")
+
+			let detailedError: string
+			if (isStopNodeError) {
+				detailedError = `Failed to parse apply_diff XML: The XML appears to be incomplete or truncated.
+
+This error typically occurs when:
+1. The XML content was cut off or truncated during generation
+2. The <diff> or <content> tags are not properly closed
+3. The AI response was interrupted before completing the XML structure
+
+To fix this issue:
+1. Try your request again - the AI may generate complete XML on retry
+2. If using a smaller context model, consider breaking the changes into smaller parts
+3. Ensure your API timeout settings allow enough time for complete responses
+
+Expected XML structure:
+<args>
+  <file>
+    <path>relative/path/to/file.ext</path>
+    <diff>
+      <content>Your diff content here</content>
+      <start_line>optional line number</start_line>
+    </diff>
+  </file>
+</args>
+
+Technical details: ${errorMessage}`
+			} else {
+				detailedError = `Failed to parse apply_diff XML. This usually means:
 1. The XML structure is malformed or incomplete
 2. Missing required <file>, <path>, or <diff> tags
 3. Invalid characters or encoding in the XML
@@ -167,10 +198,23 @@ Expected structure:
 </args>
 
 Original error: ${errorMessage}`
+			}
+
 			cline.consecutiveMistakeCount++
 			cline.recordToolError("apply_diff")
 			TelemetryService.instance.captureDiffApplicationError(cline.taskId, cline.consecutiveMistakeCount)
-			await cline.say("diff_error", `Failed to parse apply_diff XML: ${errorMessage}`)
+
+			// For StopNode errors, provide a more user-friendly message
+			if (isStopNodeError) {
+				await cline.say(
+					"diff_error",
+					"The apply_diff XML appears to be incomplete. This often happens when the response is truncated. " +
+						"Please try again, and consider breaking large changes into smaller parts if the issue persists.",
+				)
+			} else {
+				await cline.say("diff_error", `Failed to parse apply_diff XML: ${errorMessage}`)
+			}
+
 			pushToolResult(detailedError)
 			cline.processQueuedMessages()
 			return

src/utils/__tests__/xml.spec.ts

@@ -237,4 +237,81 @@ describe("parseXmlForDiff", () => {
 			expect(result.args.file.diff.content).toBe("Team Identity & Project Positioning")
 		})
 	})
+
+	describe("error handling for malformed XML", () => {
+		it("should provide helpful error message for actual parsing errors", () => {
+			// Test with XML that will actually cause a parsing error
+			const invalidXml = `<root><data>content</root></data>`
+
+			// fast-xml-parser may not throw for all malformed XML, but will parse incorrectly
+			const result = parseXml(invalidXml) as any
+			// The result will be malformed due to mismatched tags
+			expect(result).toBeDefined()
+		})
+
+		it("should validate XML structure when stopNodes are specified", () => {
+			// Test with properly closed tags
+			const validXml = `
+				<root>
+					<data>
+						<content>Valid content</content>
+					</data>
+				</root>`
+
+			// Should not throw for valid XML
+			expect(() => parseXml(validXml, ["data.content"])).not.toThrow()
+		})
+
+		it("should handle enhanced error messages for StopNode errors", () => {
+			// Create a mock error to test our enhanced error handling
+			const mockError = new Error("StopNode is not closed")
+
+			// Test that our error handling logic would enhance this error
+			const errorMessage = mockError.message
+			expect(errorMessage).toContain("StopNode is not closed")
+
+			// Verify our code would detect this as a StopNode error
+			const isStopNodeError = errorMessage.includes("StopNode is not closed")
+			expect(isStopNodeError).toBe(true)
+		})
+
+		it("should parse truncated XML without throwing (fast-xml-parser behavior)", () => {
+			// fast-xml-parser may not throw for some truncated XML
+			const truncatedXml = `
+				<args>
+					<file>
+						<path>test.js</path>
+						<diff>`
+
+			// The parser might not throw, but will return incomplete data
+			const result = parseXmlForDiff(truncatedXml, ["file.diff.content"]) as any
+			// Check that the result exists but may be incomplete
+			expect(result).toBeDefined()
+			// The diff field may be an empty string or missing
+			if (result.args?.file?.diff !== undefined) {
+				expect(typeof result.args.file.diff).toBe("string")
+			}
+		})
+
+		it("should warn about potentially malformed XML in validation", () => {
+			// Test our validation function with console.warn spy
+			const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			const xmlWithUnclosedTag = `
+				<root>
+					<content>Some content
+					<content>Another opening without close`
+
+			// Call parseXml with stopNodes to trigger validation
+			try {
+				parseXml(xmlWithUnclosedTag, ["content"])
+			} catch (error) {
+				// May or may not throw depending on parser
+			}
+
+			// Check if warning was logged
+			expect(warnSpy).toHaveBeenCalled()
+			warnSpy.mockRestore()
+		})
+	})
 })

src/utils/xml.ts

@@ -24,6 +24,11 @@ export function parseXml(xmlString: string, stopNodes?: string[], options?: Pars
 	const processEntities = options?.processEntities ?? true
 
 	try {
+		// Pre-validate XML structure if stopNodes are specified
+		if (_stopNodes && _stopNodes.length > 0) {
+			validateXmlStructure(xmlString, _stopNodes)
+		}
+
 		const parser = new XMLParser({
 			ignoreAttributes: false,
 			attributeNamePrefix: "@_",
@@ -38,10 +43,60 @@ export function parseXml(xmlString: string, stopNodes?: string[], options?: Pars
 	} catch (error) {
 		// Enhance error message for better debugging
 		const errorMessage = error instanceof Error ? error.message : "Unknown error"
+
+		// Check for specific error patterns and provide helpful guidance
+		if (errorMessage.includes("StopNode is not closed")) {
+			const stopNodePath = _stopNodes?.join(", ") || "none"
+			throw new Error(
+				`Failed to parse XML: ${errorMessage}\n\n` +
+					`This error typically occurs when:\n` +
+					`1. The XML structure is incomplete or malformed\n` +
+					`2. A tag specified in stopNodes (${stopNodePath}) is not properly closed\n` +
+					`3. The XML content is truncated or cut off\n\n` +
+					`Please ensure your XML is complete and all tags are properly closed.`,
+			)
+		}
+
 		throw new Error(`Failed to parse XML: ${errorMessage}`)
 	}
 }
 
+/**
+ * Validates that XML structure has properly closed tags for stopNodes
+ * @param xmlString The XML string to validate
+ * @param stopNodes Array of node paths to check
+ * @throws Error if validation fails
+ */
+function validateXmlStructure(xmlString: string, stopNodes: string[]): void {
+	// Basic validation to catch common issues before parsing
+	for (const stopNode of stopNodes) {
+		// Convert dot notation to tag hierarchy
+		const tags = stopNode.split(".")
+		const lastTag = tags[tags.length - 1]
+
+		// Check if the tag appears to be opened but not closed
+		const openTagPattern = new RegExp(`<${lastTag}[^>]*>`, "g")
+		const closeTagPattern = new RegExp(`</${lastTag}>`, "g")
+
+		const openMatches = xmlString.match(openTagPattern) || []
+		const closeMatches = xmlString.match(closeTagPattern) || []
+
+		// If we have more open tags than close tags, it might be malformed
+		if (openMatches.length > closeMatches.length) {
+			// Check if the XML appears to be truncated
+			const lastCloseTagIndex = xmlString.lastIndexOf(`</${lastTag}>`)
+			const lastOpenTagIndex = xmlString.lastIndexOf(`<${lastTag}`)
+
+			if (lastOpenTagIndex > lastCloseTagIndex) {
+				console.warn(
+					`Warning: XML may be truncated or malformed. ` +
+						`Tag <${lastTag}> appears to be opened but not closed properly.`,
+				)
+			}
+		}
+	}
+}
+
 /**
  * Parses an XML string for diffing purposes, ensuring no HTML entities are decoded.
  * This is a specialized version of parseXml to be used exclusively by diffing tools