fix(ui): improve Mermaid diagram rendering - bar chart, flowchart, xy chart

**Problem:**
Multiple Mermaid diagram types had rendering and parsing issues:
1. Bar charts only showed one bar instead of all bars
2. Flowchart arrows were invisible
3. XY charts couldn't parse coordinate pair format
4. Class diagrams didn't parse attributes/methods
5. Mindmaps didn't parse hierarchical structure

**Solutions:**

1. **Bar Chart - Fixed Two Bugs:**
   - Parser Bug: Expected 'bar Label: Value' syntax, but Mermaid uses 'Label: Value'
     → Updated parseBarChart() to handle correct syntax without 'bar' prefix
   - Rendering Bug: ForEach ID collision - both loops used `id: \.offset`
     → Changed outer loop to `id: \.element.id`, inner to `ForEach(0..<count, id: \.self)`

2. **Flowchart Arrows:**
   - ArrowHead created open V-shaped path but tried to .fill() it (can't fill open paths)
   → Added .closeSubpath() to create closed triangle that can be filled
   → Result: Solid filled arrow triangles now visible

3. **XY Chart Coordinate Pairs:**
   - Parser only handled simple value arrays: [1, 2, 3]
   - Couldn't parse coordinate pairs: [1, 20], [2, 22], [3, 21]
   → Added parseCoordinatePairs() using regex to extract Y values from [x,y] format
   → Added series label parsing: "Series1: [coordinates]"

4. **Class Diagram Attributes/Methods:**
   - Parser detected class definitions but ignored body contents
   → Added state tracking for multi-line class bodies
   → Parses attributes (non-parenthesis lines) and methods (lines with parentheses)
   → Handles opening/closing braces correctly

5. **Mindmap Hierarchy:**
   - Only parsed root node, ignored all children
   → Added buildMindmapTree() recursive function
   → Tracks indentation (2 spaces = 1 level) to build tree structure
   → Creates complete hierarchical node tree

**Additional Fix:**
- Read Tool Result: Improved tool description for better LLM understanding

**Files Modified:**
- Sources/MCPFramework/Tools/ReadToolResultTool.swift (description)
- Sources/UserInterface/Chat/Mermaid/MermaidParser.swift (5 parser fixes)
- Sources/UserInterface/Chat/Mermaid/XYChartRenderer.swift (ForEach IDs)
- Sources/UserInterface/Chat/Mermaid/FlowchartRenderer.swift (arrow closeSubpath)

**Testing:**
✅ Build: PASS
✅ Bar Chart: 4 bars render correctly with labels (Apples, Bananas, Oranges, Grapes)
✅ Flowchart: Arrows visible with solid fill
✅ XY Chart: Parsing updated (needs user testing)
✅ Class Diagram: Parsing updated (rendering issues remain - see handoff)
✅ Mindmap: Parsing updated (rendering issues remain - see handoff)

**Known Issues (Documented in Handoff):**
- Class diagrams: Relationships parsed but not rendered (no lines showing)
- Mindmaps: Tree structure parsed but only root displays
- Other diagrams: Need arrows added (sequence, state, ER)

**Handoff Documentation:**
- ai-assisted/2026-01-06/mermaid-fixes/CONTINUATION_PROMPT.md
- ai-assisted/2026-01-06/mermaid-fixes/AGENT_PLAN.md

**Next Session Work:**
1. Fix ClassDiagramRenderer to draw relationship lines
2. Fix MindmapRenderer to display all nodes recursively
3. Add arrows to sequence, state, and ER diagrams

Author: fewtarius

Sources/UserInterface/Chat/Mermaid/FlowchartRenderer.swift

@@ -774,11 +774,11 @@ struct ArrowHead: Shape {
             x: at.x - arrowLength * cos(angle - arrowAngle),
             y: at.y - arrowLength * sin(angle - arrowAngle)
         ))
-        path.move(to: at)
         path.addLine(to: CGPoint(
             x: at.x - arrowLength * cos(angle + arrowAngle),
             y: at.y - arrowLength * sin(angle + arrowAngle)
         ))
+        path.closeSubpath()  // Close the triangle to make it fillable
 
         return path
     }

Sources/UserInterface/Chat/Mermaid/MermaidParser.swift

@@ -576,24 +576,54 @@ struct MermaidParser {
         var classes: [ClassNode] = []
         var relationships: [ClassRelationship] = []
         var classMap: [String: ClassNode] = [:]
+        var currentClass: String?
+        var currentAttributes: [String] = []
+        var currentMethods: [String] = []
 
         for line in lines {
-            // Parse class definition
-            if line.hasPrefix("class ") {
+            // Check if we're ending a class definition
+            if line == "}" && currentClass != nil {
+                // Save the class with its attributes and methods
+                if let className = currentClass {
+                    let classNode = ClassNode(
+                        id: className,
+                        name: className,
+                        attributes: currentAttributes,
+                        methods: currentMethods,
+                        stereotype: nil
+                    )
+                    if let existingIndex = classes.firstIndex(where: { $0.id == className }) {
+                        classes[existingIndex] = classNode
+                    } else {
+                        classes.append(classNode)
+                    }
+                    classMap[className] = classNode
+                }
+                currentClass = nil
+                currentAttributes = []
+                currentMethods = []
+            }
+            // Parse class definition start
+            else if line.hasPrefix("class ") {
                 let className = line.replacingOccurrences(of: "class ", with: "")
                     .trimmingCharacters(in: .whitespaces)
                     .components(separatedBy: "{")[0]
                     .trimmingCharacters(in: .whitespaces)
 
-                let classNode = ClassNode(
-                    id: className,
-                    name: className,
-                    attributes: [],
-                    methods: [],
-                    stereotype: nil
-                )
-                classes.append(classNode)
-                classMap[className] = classNode
+                currentClass = className
+                currentAttributes = []
+                currentMethods = []
+            }
+            // Parse attributes and methods inside class body
+            else if currentClass != nil {
+                let trimmed = line.trimmingCharacters(in: .whitespaces)
+                if trimmed.contains("(") {
+                    // It's a method
+                    currentMethods.append(trimmed)
+                } else if !trimmed.isEmpty && trimmed != "{" {
+                    // It's an attribute
+                    currentAttributes.append(trimmed)
+                }
             }
             // Parse relationship
             else if line.contains("<|--") || line.contains("*--") || line.contains("o--") ||
@@ -604,6 +634,23 @@ struct MermaidParser {
             }
         }
 
+        // Handle case where class definition doesn't have closing brace
+        if let className = currentClass {
+            let classNode = ClassNode(
+                id: className,
+                name: className,
+                attributes: currentAttributes,
+                methods: currentMethods,
+                stereotype: nil
+            )
+            if let existingIndex = classes.firstIndex(where: { $0.id == className }) {
+                classes[existingIndex] = classNode
+            } else {
+                classes.append(classNode)
+            }
+            classMap[className] = classNode
+        }
+
         let diagram = ClassDiagram(classes: classes, relationships: relationships)
         return .classDiagram(diagram)
     }
@@ -938,18 +985,66 @@ struct MermaidParser {
 
     private func parseMindmap(_ code: String) -> MermaidDiagram {
         let lines = code.components(separatedBy: .newlines)
-            .map { $0.trimmingCharacters(in: .whitespaces) }
-            .filter { !$0.isEmpty && $0 != "mindmap" && !$0.hasPrefix("%%") }
+            .filter { !$0.trimmingCharacters(in: .whitespaces).isEmpty &&
+                      $0.trimmingCharacters(in: .whitespaces) != "mindmap" &&
+                      !$0.trimmingCharacters(in: .whitespaces).hasPrefix("%%") }
 
         guard let rootLine = lines.first else {
             return .unsupported(code)
         }
 
-        let root = MindmapNode(id: "root", label: rootLine, children: [], level: 0)
+        // Parse root node (remove parentheses if present)
+        let rootLabel = rootLine.trimmingCharacters(in: .whitespaces)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "()"))
+            .trimmingCharacters(in: .whitespaces)
+
+        // Parse hierarchy - build list of (label, level) pairs
+        var nodeData: [(label: String, level: Int)] = [(rootLabel, 0)]
+
+        for line in lines.dropFirst() {
+            let trimmed = line.trimmingCharacters(in: .whitespaces)
+            guard !trimmed.isEmpty else { continue }
+
+            let leadingSpaces = line.prefix(while: { $0 == " " }).count
+            let level = leadingSpaces / 2 + 1  // Each 2 spaces = 1 level
+
+            nodeData.append((trimmed, level))
+        }
+
+        // Build tree recursively
+        let (root, _) = buildMindmapTree(nodeData: nodeData, startIndex: 0, parentLevel: -1)
+
         let mindmap = Mindmap(root: root)
         return .mindmap(mindmap)
     }
 
+    /// Recursively build mindmap tree from flat node data
+    private func buildMindmapTree(nodeData: [(label: String, level: Int)], startIndex: Int, parentLevel: Int) -> (MindmapNode, Int) {
+        guard startIndex < nodeData.count else {
+            return (MindmapNode(id: "empty", label: "", children: [], level: 0), startIndex)
+        }
+
+        let (label, level) = nodeData[startIndex]
+        let nodeId = "node_\(startIndex)"
+
+        var children: [MindmapNode] = []
+        var currentIndex = startIndex + 1
+
+        // Collect all direct children (level = current + 1)
+        while currentIndex < nodeData.count && nodeData[currentIndex].level > level {
+            if nodeData[currentIndex].level == level + 1 {
+                let (child, nextIndex) = buildMindmapTree(nodeData: nodeData, startIndex: currentIndex, parentLevel: level)
+                children.append(child)
+                currentIndex = nextIndex
+            } else {
+                currentIndex += 1
+            }
+        }
+
+        let node = MindmapNode(id: nodeId, label: label, children: children, level: level)
+        return (node, currentIndex)
+    }
+
     // MARK: - Timeline Parsing
 
     private func parseTimeline(_ code: String) -> MermaidDiagram {
@@ -1137,18 +1232,17 @@ struct MermaidParser {
                 yAxisLabel = line.replacingOccurrences(of: "y-axis ", with: "")
                     .trimmingCharacters(in: CharacterSet(charactersIn: "\""))
             }
-            // Parse bar with label:value format (e.g., "bar January: 35" or "bar \"January\": 35")
-            else if line.hasPrefix("bar ") {
-                let rest = line.replacingOccurrences(of: "bar ", with: "")
-                // Split by colon to get label and value
-                if let colonIndex = rest.lastIndex(of: ":") {
-                    let label = String(rest[..<colonIndex])
+            // Parse data with label:value format (e.g., "Apples: 35" or "\"January\": 35")
+            // Note: barChart syntax does NOT require "bar" prefix
+            else if line.contains(":") && !line.hasPrefix("title") && !line.hasPrefix("x-axis") && !line.hasPrefix("y-axis") {
+                if let colonIndex = line.lastIndex(of: ":") {
+                    let label = String(line[..<colonIndex])
                         .trimmingCharacters(in: .whitespaces)
                         .trimmingCharacters(in: CharacterSet(charactersIn: "\""))
-                    let valueStr = String(rest[rest.index(after: colonIndex)...])
+                    let valueStr = String(line[line.index(after: colonIndex)...])
                         .trimmingCharacters(in: .whitespaces)
 
-                    if let value = Double(valueStr) {
+                    if let value = Double(valueStr), !label.isEmpty {
                         categories.append(label)
                         values.append(value)
                     }
@@ -1247,6 +1341,19 @@ struct MermaidParser {
                     dataSeries.append(series)
                 }
             }
+            // Parse series data with label (e.g., "Series1: [1, 20], [2, 22], [3, 21]")
+            else if line.contains(":") && line.contains("[") {
+                // Extract series label and data
+                if let colonIndex = line.firstIndex(of: ":") {
+                    let seriesLabel = String(line[..<colonIndex]).trimmingCharacters(in: .whitespaces)
+                    let dataStr = String(line[line.index(after: colonIndex)...]).trimmingCharacters(in: .whitespaces)
+                    
+                    // Check if this is coordinate pairs format: [x, y], [x, y]
+                    if let series = parseCoordinatePairs(dataStr, label: seriesLabel) {
+                        dataSeries.append(series)
+                    }
+                }
+            }
         }
 
         let chart = XYChart(
@@ -1288,4 +1395,30 @@ struct MermaidParser {
 
         return XYDataSeries(type: type, values: values, label: label)
     }
+    
+    /// Parse coordinate pairs format: [1, 20], [2, 22], [3, 21], [4, 23]
+    /// Extracts just the Y values since X values are typically sequential
+    private func parseCoordinatePairs(_ line: String, label: String) -> XYDataSeries? {
+        // Match all [x, y] pairs
+        let pattern = "\\[(\\d+(?:\\.\\d+)?),\\s*(\\d+(?:\\.\\d+)?)\\]"
+        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
+        
+        let nsString = line as NSString
+        let matches = regex.matches(in: line, range: NSRange(location: 0, length: nsString.length))
+        
+        var yValues: [Double] = []
+        for match in matches {
+            // Extract Y value (second capture group)
+            if match.numberOfRanges >= 3 {
+                let yRange = match.range(at: 2)
+                if let yValue = Double(nsString.substring(with: yRange)) {
+                    yValues.append(yValue)
+                }
+            }
+        }
+        
+        guard !yValues.isEmpty else { return nil }
+        
+        return XYDataSeries(type: .line, values: yValues, label: label)
+    }
 }

Sources/UserInterface/Chat/Mermaid/XYChartRenderer.swift

@@ -174,7 +174,7 @@ struct XYChartRenderer: View {
             }
 
             // Draw bar series
-            ForEach(Array(chart.dataSeries.enumerated()), id: \.offset) { seriesIndex, series in
+            ForEach(Array(chart.dataSeries.enumerated()), id: \.element.id) { seriesIndex, series in
                 if series.type == .bar {
                     barSeries(
                         series: series,
@@ -191,7 +191,7 @@ struct XYChartRenderer: View {
             }
 
             // Draw line series on top
-            ForEach(Array(chart.dataSeries.enumerated()), id: \.offset) { seriesIndex, series in
+            ForEach(Array(chart.dataSeries.enumerated()), id: \.element.id) { seriesIndex, series in
                 if series.type == .line {
                     lineSeries(
                         series: series,
@@ -226,7 +226,8 @@ struct XYChartRenderer: View {
     /// Draw a bar series with value labels
     @ViewBuilder
     private func barSeries(series: XYDataSeries, seriesIndex: Int, width: CGFloat, height: CGFloat, barWidth: CGFloat, barGroupWidth: CGFloat, valueRange: Double, zeroY: CGFloat, color: Color) -> some View {
-        ForEach(Array(series.values.enumerated()), id: \.offset) { index, value in
+        ForEach(0..<series.values.count, id: \.self) { index in
+            let value = series.values[index]
             // Calculate bar height: from 0 line to value
             let valueY = height * CGFloat((maxValue - value) / valueRange)
             let barHeight = abs(zeroY - valueY)