Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

apps/shared/OpenClawKit/Sources/OpenClawChatUI/ChatMarkdownRenderer.swift

@@ -0,0 +1,241 @@
+import Foundation
+import SwiftUI
+
+public enum ChatMarkdownVariant: String, CaseIterable, Sendable {
+    case standard
+    case compact
+}
+
+@MainActor
+struct ChatMarkdownRenderer: View {
+    enum Context {
+        case user
+        case assistant
+    }
+
+    let text: String
+    let context: Context
+    let variant: ChatMarkdownVariant
+    let font: Font
+    let textColor: Color
+
+    var body: some View {
+        let processed = ChatMarkdownPreprocessor.preprocess(markdown: self.text)
+        let renderMarkdown = ChatMarkdownDisplayPreprocessor.preserveChatSoftBreaks(in: processed.cleaned)
+        VStack(alignment: .leading, spacing: 10) {
+            Text(self.markdownText(renderMarkdown))
+                .font(self.font)
+                .foregroundStyle(self.textColor)
+                .tint(self.linkColor)
+                .textSelection(.enabled)
+                .lineSpacing(self.variant == .compact ? 2 : 4)
+
+            if !processed.images.isEmpty {
+                InlineImageList(images: processed.images)
+            }
+        }
+    }
+
+    private var linkColor: Color {
+        self.context == .user ? self.textColor : OpenClawChatTheme.accent
+    }
+
+    private func markdownText(_ markdown: String) -> AttributedString {
+        let options = AttributedString.MarkdownParsingOptions(
+            interpretedSyntax: .full,
+            failurePolicy: .returnPartiallyParsedIfPossible)
+        return (try? AttributedString(markdown: markdown, options: options)) ?? AttributedString(markdown)
+    }
+}
+
+enum ChatMarkdownDisplayPreprocessor {
+    static func preserveChatSoftBreaks(in markdown: String) -> String {
+        let normalized = markdown.replacingOccurrences(of: "\r\n", with: "\n")
+        let lines = normalized.split(separator: "\n", omittingEmptySubsequences: false).map(String.init)
+        guard lines.count > 1 else { return normalized }
+
+        var output = ""
+        var fence: Fence?
+        let tableRows = self.tableRowIndices(in: lines)
+
+        for index in lines.indices {
+            let line = lines[index]
+            let wasInFence = fence != nil
+            let fenceBoundary = self.fenceBoundary(in: line, activeFence: fence)
+            if case let .open(nextFence) = fenceBoundary {
+                fence = nextFence
+            } else if case .close = fenceBoundary {
+                fence = nil
+            }
+
+            output += line
+
+            guard index < lines.index(before: lines.endIndex) else {
+                continue
+            }
+
+            let nextLine = lines[lines.index(after: index)]
+            let nextIndex = lines.index(after: index)
+            if self.shouldPreserveSoftBreak(
+                after: line,
+                before: nextLine,
+                inTable: tableRows.contains(index) || tableRows.contains(nextIndex),
+                inFence: wasInFence,
+                fenceBoundary: fenceBoundary)
+            {
+                output += "  \n"
+            } else {
+                output += "\n"
+            }
+        }
+
+        return output
+    }
+
+    private enum FenceBoundary {
+        case none
+        case open(Fence)
+        case close
+    }
+
+    private struct Fence {
+        let character: Character
+        let count: Int
+        let hasOnlyTrailingWhitespace: Bool
+    }
+
+    private static func shouldPreserveSoftBreak(
+        after line: String,
+        before nextLine: String,
+        inTable: Bool,
+        inFence: Bool,
+        fenceBoundary: FenceBoundary) -> Bool
+    {
+        guard !inTable else { return false }
+        guard !inFence else { return false }
+        guard case .none = fenceBoundary else { return false }
+
+        let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
+        let nextTrimmed = nextLine.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty, !nextTrimmed.isEmpty else { return false }
+        guard !self.hasMarkdownHardBreak(line) else { return false }
+        guard !self.isBlockMarkdownLine(line), !self.isBlockMarkdownLine(nextLine) else { return false }
+        return true
+    }
+
+    private static func hasMarkdownHardBreak(_ line: String) -> Bool {
+        line.hasSuffix("\\") || line.hasSuffix("  ")
+    }
+
+    private static func isBlockMarkdownLine(_ line: String) -> Bool {
+        let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else { return false }
+
+        return self.matches(line, #"^\s{0,3}#{1,6}(\s|$)"#)
+            || self.matches(line, #"^\s{0,3}>"#)
+            || self.matches(line, #"^\s{0,3}([-+*])\s+"#)
+            || self.matches(line, #"^\s{0,3}\d{1,9}[.)]\s+"#)
+            || self.matches(line, #"^( {4}|\t)"#)
+            || self.matches(line, #"^\s{0,3}((\*\s*){3,}|(-\s*){3,}|(_\s*){3,}|={3,})$"#)
+    }
+
+    private static func tableRowIndices(in lines: [String]) -> Set<Int> {
+        var indices = Set<Int>()
+        for index in lines.indices where index > lines.startIndex {
+            guard self.isTableDelimiterLine(lines[index]), lines[lines.index(before: index)].contains("|") else {
+                continue
+            }
+
+            indices.insert(lines.index(before: index))
+            indices.insert(index)
+
+            var cursor = lines.index(after: index)
+            while cursor < lines.endIndex, lines[cursor].contains("|") {
+                indices.insert(cursor)
+                cursor = lines.index(after: cursor)
+            }
+        }
+        return indices
+    }
+
+    private static func isTableDelimiterLine(_ line: String) -> Bool {
+        self.matches(line, #"^\s{0,3}\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$"#)
+    }
+
+    private static func fenceBoundary(in line: String, activeFence: Fence?) -> FenceBoundary {
+        guard let candidate = self.fenceCandidate(in: line) else {
+            return .none
+        }
+
+        guard let activeFence else {
+            return .open(candidate)
+        }
+
+        if candidate.character == activeFence.character,
+           candidate.count >= activeFence.count,
+           candidate.hasOnlyTrailingWhitespace
+        {
+            return .close
+        }
+        return .none
+    }
+
+    private static func fenceCandidate(in line: String) -> Fence? {
+        var cursor = line.startIndex
+        var spaces = 0
+        while cursor < line.endIndex, line[cursor] == " ", spaces < 4 {
+            spaces += 1
+            cursor = line.index(after: cursor)
+        }
+        guard spaces <= 3, cursor < line.endIndex else {
+            return nil
+        }
+
+        let character = line[cursor]
+        guard character == "`" || character == "~" else {
+            return nil
+        }
+
+        var count = 0
+        while cursor < line.endIndex, line[cursor] == character {
+            count += 1
+            cursor = line.index(after: cursor)
+        }
+        guard count >= 3 else {
+            return nil
+        }
+        let trailing = line[cursor...]
+        return Fence(
+            character: character,
+            count: count,
+            hasOnlyTrailingWhitespace: trailing.allSatisfy(\.isWhitespace))
+    }
+
+    private static func matches(_ line: String, _ pattern: String) -> Bool {
+        line.range(of: pattern, options: .regularExpression) != nil
+    }
+}
+
+@MainActor
+private struct InlineImageList: View {
+    let images: [ChatMarkdownPreprocessor.InlineImage]
+
+    var body: some View {
+        ForEach(self.images, id: \.id) { item in
+            if let img = item.image {
+                OpenClawPlatformImageFactory.image(img)
+                    .resizable()
+                    .scaledToFit()
+                    .frame(maxHeight: 260)
+                    .clipShape(RoundedRectangle(cornerRadius: 12, style: .continuous))
+                    .overlay(
+                        RoundedRectangle(cornerRadius: 12, style: .continuous)
+                            .strokeBorder(Color.white.opacity(0.12), lineWidth: 1))
+            } else {
+                Text(item.label.isEmpty ? "Image" : item.label)
+                    .font(OpenClawChatTypography.footnote)
+                    .foregroundStyle(.secondary)
+            }
+        }
+    }
+}