feat(swiftlmchat): HuggingFace live search + font/color fixes

HFModelSearch.swift (new, MLXInferenceCore):
- Mirrors Aegis-AI LocalLanguageModels/modelService pattern exactly
- HF API: library=mlx, pipeline_tag=text-generation, sort=trending/downloads/likes/lastModified
- 300ms debounce on keystroke, pagination (loadMore)
- HFModelResult: paramSizeHint, isMoE, downloadsDisplay, likesDisplay

ModelPickerView.swift (rewrite):
- Segmented tab: Catalog (curated) | Search HF (live search)
- HFSearchTab: search bar, sort chips, load-more, error states, empty state
- HFModelRow: mlx-community badge, MoE badge, param size badge, download stats
- Catalog tab restructured into CatalogTab private struct

MessageBubble.swift (rewrite):
- NSColor.controlBackgroundColor / UIColor.secondarySystemBackground
  → adaptive in both light and dark mode (fixes washed-out/invisible bubbles)
- .foregroundStyle(.primary) explicit on all message text
- Subtle drop shadow for bubble depth
- Corner radius 18 (was 16), slightly larger avatar icon

Author: solderzzc

Sources/MLXInferenceCore/HFModelSearch.swift

@@ -0,0 +1,167 @@
+// HFModelSearch.swift — Live HuggingFace model search for MLX models
+//
+// API: https://huggingface.co/api/models?library=mlx&pipeline_tag=text-generation
+//      &search=<query>&sort=trending&limit=20&full=false
+//
+// Mirrors the Aegis-AI pattern (LocalLanguageModels.tsx + modelService.ts):
+//   library=mlx  →  filters to MLX-format models (mlx-community and others)
+//   pipeline_tag →  text-generation or text2text-generation
+//   sort         →  trending (default), downloads, likes, lastModified
+
+import Foundation
+
+// MARK: — HF API model result
+
+public struct HFModelResult: Identifiable, Sendable, Decodable {
+    public let id: String               // e.g. "mlx-community/Qwen2.5-7B-Instruct-4bit"
+    public let likes: Int?
+    public let downloads: Int?
+    public let pipeline_tag: String?    // "text-generation"
+    public let tags: [String]?
+
+    // Computed helpers
+    public var repoOwner: String { String(id.split(separator: "/").first ?? "") }
+    public var repoName: String  { String(id.split(separator: "/").last  ?? "") }
+    public var isMlxCommunity: Bool { repoOwner == "mlx-community" }
+
+    /// Best-effort parameter size extracted from the model ID name.
+    public var paramSizeHint: String? {
+        let patterns = [
+            #"(\d+\.?\d*)[Bb]"#,   // 7B, 0.5B, 3.8B
+            #"(\d+)[xX](\d+)[Bb]"# // 8x7B MoE
+        ]
+        for pattern in patterns {
+            if let match = repoName.range(of: pattern, options: .regularExpression) {
+                return String(repoName[match])
+            }
+        }
+        return nil
+    }
+
+    /// True if the model name suggests MoE architecture.
+    public var isMoE: Bool {
+        let lower = repoName.lowercased()
+        return lower.contains("moe") || lower.contains("-a") || lower.contains("_a")
+    }
+
+    public var downloadsDisplay: String {
+        guard let d = downloads else { return "" }
+        if d >= 1_000_000 { return String(format: "%.1fM↓", Double(d) / 1_000_000) }
+        if d >= 1_000     { return String(format: "%.0fk↓", Double(d) / 1_000) }
+        return "\(d)↓"
+    }
+
+    public var likesDisplay: String {
+        guard let l = likes, l > 0 else { return "" }
+        if l >= 1_000 { return String(format: "%.0fk♥", Double(l) / 1_000) }
+        return "\(l)♥"
+    }
+}
+
+// MARK: — Sort options (matching Aegis-AI LocalLanguageModels sort selector)
+
+public enum HFSortOption: String, CaseIterable, Sendable {
+    case trending    = "trending"
+    case downloads   = "downloads"
+    case likes       = "likes"
+    case lastModified = "lastModified"
+
+    public var label: String {
+        switch self {
+        case .trending:     return "Trending"
+        case .downloads:    return "Downloads"
+        case .likes:        return "Likes"
+        case .lastModified: return "Newest"
+        }
+    }
+}
+
+// MARK: — HFModelSearchService
+
+@MainActor
+public final class HFModelSearchService: ObservableObject {
+    public static let shared = HFModelSearchService()
+
+    @Published public var results: [HFModelResult] = []
+    @Published public var isSearching = false
+    @Published public var errorMessage: String? = nil
+    @Published public var hasMore = false
+
+    private let hfBase = "https://huggingface.co/api/models"
+    private let pageSize = 20
+    private var currentOffset = 0
+    private var currentQuery = ""
+    private var currentSort = HFSortOption.trending
+    private var debounceTask: Task<Void, Never>? = nil
+
+    private init() {}
+
+    // MARK: — Public API
+
+    /// Debounced search — safe to call on every keystroke.
+    public func search(query: String, sort: HFSortOption = .trending) {
+        debounceTask?.cancel()
+        debounceTask = Task {
+            // 300ms debounce
+            try? await Task.sleep(nanoseconds: 300_000_000)
+            guard !Task.isCancelled else { return }
+            currentQuery = query
+            currentSort  = sort
+            currentOffset = 0
+            results = []
+            await fetchPage()
+        }
+    }
+
+    /// Load next page of results.
+    public func loadMore() {
+        guard hasMore, !isSearching else { return }
+        Task { await fetchPage() }
+    }
+
+    // MARK: — Private
+
+    private func fetchPage() async {
+        isSearching = true
+        errorMessage = nil
+
+        var components = URLComponents(string: hfBase)!
+        var queryItems: [URLQueryItem] = [
+            // MLX format filter (matches Aegis-AI: library_name=mlx)
+            URLQueryItem(name: "library",      value: "mlx"),
+            URLQueryItem(name: "pipeline_tag", value: "text-generation"),
+            URLQueryItem(name: "sort",         value: currentSort.rawValue),
+            URLQueryItem(name: "limit",        value: "\(pageSize)"),
+            URLQueryItem(name: "offset",       value: "\(currentOffset)"),
+            URLQueryItem(name: "full",         value: "false"),
+        ]
+        if !currentQuery.isEmpty {
+            queryItems.append(URLQueryItem(name: "search", value: currentQuery))
+        }
+        components.queryItems = queryItems
+
+        guard let url = components.url else {
+            isSearching = false
+            return
+        }
+
+        do {
+            let (data, response) = try await URLSession.shared.data(from: url)
+            guard let http = response as? HTTPURLResponse, http.statusCode == 200 else {
+                errorMessage = "HuggingFace search unavailable"
+                isSearching = false
+                return
+            }
+            let page = try JSONDecoder().decode([HFModelResult].self, from: data)
+            results.append(contentsOf: page)
+            hasMore = page.count == pageSize
+            currentOffset += page.count
+        } catch is CancellationError {
+            // no-op
+        } catch {
+            errorMessage = "Search failed: \(error.localizedDescription)"
+        }
+
+        isSearching = false
+    }
+}

SwiftLMChat/SwiftLMChat/Views/MessageBubble.swift

@@ -1,6 +1,29 @@
 // MessageBubble.swift — Chat message bubble + live streaming bubble
 import SwiftUI
 
+// MARK: — Shared adaptive colors
+
+private extension Color {
+    /// Assistant bubble background — works in both light and dark mode.
+    /// Light mode: warm near-white. Dark mode: elevated dark fill.
+    static var assistantBubble: Color {
+        #if os(macOS)
+        return Color(NSColor.controlBackgroundColor)
+        #else
+        return Color(UIColor.secondarySystemBackground)
+        #endif
+    }
+
+    /// Subtle inner tint for thinking disclosure group.
+    static var thinkingBubble: Color {
+        #if os(macOS)
+        return Color(NSColor.windowBackgroundColor)
+        #else
+        return Color(UIColor.tertiarySystemBackground)
+        #endif
+    }
+}
+
 // MARK: — Static Message Bubble
 
 struct MessageBubble: View {
@@ -15,27 +38,32 @@ struct MessageBubble: View {
             if !isUser {
                 // Avatar
                 Circle()
-                    .fill(LinearGradient(colors: [.blue, .purple], startPoint: .topLeading, endPoint: .bottomTrailing))
+                    .fill(LinearGradient(
+                        colors: [.blue, .purple],
+                        startPoint: .topLeading, endPoint: .bottomTrailing
+                    ))
                     .frame(width: 28, height: 28)
                     .overlay(
                         Image(systemName: "cpu")
-                            .font(.caption2)
+                            .font(.system(size: 11, weight: .semibold))
                             .foregroundStyle(.white)
                     )
             }
 
             VStack(alignment: isUser ? .trailing : .leading, spacing: 4) {
                 Text(message.content)
+                    .font(.system(.body, design: .default))
                     .textSelection(.enabled)
                     .padding(.horizontal, 12)
                     .padding(.vertical, 8)
-                    .background(isUser ? Color.accentColor : Color(white: 0.92))
+                    .background(isUser ? Color.accentColor : Color.assistantBubble)
                     .foregroundStyle(isUser ? .white : .primary)
                     .clipShape(BubbleShape(isUser: isUser))
+                    .shadow(color: .black.opacity(0.06), radius: 2, x: 0, y: 1)
 
                 Text(message.timestamp, style: .time)
                     .font(.caption2)
-                    .foregroundStyle(.secondary)
+                    .foregroundStyle(.tertiary)
             }
 
             if !isUser { Spacer(minLength: 60) }
@@ -48,32 +76,35 @@ struct MessageBubble: View {
 struct StreamingBubble: View {
     let text: String
     let thinkingText: String?
-    @State private var dotPhase = 0
+    @State private var cursorVisible = true
 
     var body: some View {
         HStack(alignment: .bottom, spacing: 8) {
             Circle()
-                .fill(LinearGradient(colors: [.blue, .purple], startPoint: .topLeading, endPoint: .bottomTrailing))
+                .fill(LinearGradient(
+                    colors: [.blue, .purple],
+                    startPoint: .topLeading, endPoint: .bottomTrailing
+                ))
                 .frame(width: 28, height: 28)
                 .overlay(
                     Image(systemName: "cpu")
-                        .font(.caption2)
+                        .font(.system(size: 11, weight: .semibold))
                         .foregroundStyle(.white)
                 )
 
             VStack(alignment: .leading, spacing: 6) {
-                // Thinking section (collapsed by default, shows thought process)
+                // Thinking section
                 if let thinking = thinkingText, !thinking.isEmpty {
                     DisclosureGroup {
                         Text(thinking)
                             .font(.caption)
                             .foregroundStyle(.secondary)
                             .padding(8)
-                            .background(Color(white: 0.95))
-                            .clipShape(RoundedRectangle(cornerRadius: 8))
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                            .background(Color.thinkingBubble, in: RoundedRectangle(cornerRadius: 8))
                     } label: {
                         Label("Thinking…", systemImage: "brain")
-                            .font(.caption)
+                            .font(.caption.weight(.medium))
                             .foregroundStyle(.secondary)
                     }
                 }
@@ -82,31 +113,33 @@ struct StreamingBubble: View {
                 if !text.isEmpty {
                     HStack(alignment: .bottom, spacing: 2) {
                         Text(text)
+                            .font(.system(.body, design: .default))
+                            .foregroundStyle(.primary)
                             .textSelection(.enabled)
                         // Blinking cursor
                         RoundedRectangle(cornerRadius: 1)
                             .frame(width: 2, height: 16)
                             .foregroundStyle(.blue)
-                            .opacity(dotPhase % 2 == 0 ? 1 : 0)
-                            .animation(.easeInOut(duration: 0.5).repeatForever(), value: dotPhase)
+                            .opacity(cursorVisible ? 1 : 0)
+                            .animation(.easeInOut(duration: 0.5).repeatForever(), value: cursorVisible)
                     }
                     .padding(.horizontal, 12)
                     .padding(.vertical, 8)
-                    .background(Color(white: 0.92))
+                    .background(Color.assistantBubble)
                     .clipShape(BubbleShape(isUser: false))
+                    .shadow(color: .black.opacity(0.06), radius: 2, x: 0, y: 1)
                 } else {
-                    // Typing dots when no text yet
                     TypingIndicator()
                         .padding(.horizontal, 12)
-                        .padding(.vertical, 8)
-                        .background(Color(white: 0.92))
+                        .padding(.vertical, 10)
+                        .background(Color.assistantBubble)
                         .clipShape(BubbleShape(isUser: false))
                 }
             }
 
             Spacer(minLength: 60)
         }
-        .onAppear { dotPhase = 1 }
+        .onAppear { cursorVisible = false }
     }
 }
 
@@ -116,37 +149,36 @@ struct TypingIndicator: View {
     @State private var phase = 0
 
     var body: some View {
-        HStack(spacing: 4) {
+        HStack(spacing: 5) {
             ForEach(0..<3) { i in
                 Circle()
-                    .frame(width: 6, height: 6)
+                    .frame(width: 7, height: 7)
                     .foregroundStyle(.secondary)
-                    .scaleEffect(phase == i ? 1.3 : 0.8)
+                    .scaleEffect(phase == i ? 1.4 : 0.8)
                     .animation(
-                        .easeInOut(duration: 0.4).repeatForever().delay(Double(i) * 0.15),
+                        .easeInOut(duration: 0.45)
+                            .repeatForever()
+                            .delay(Double(i) * 0.15),
                         value: phase
                     )
             }
         }
-        .onAppear {
-            withAnimation { phase = 1 }
-        }
+        .onAppear { withAnimation { phase = 1 } }
     }
 }
 
 // MARK: — Bubble Shape
 
 struct BubbleShape: Shape {
     let isUser: Bool
-    let radius: CGFloat = 16
+    let radius: CGFloat = 18
 
     func path(in rect: CGRect) -> Path {
+        let tl: CGFloat = isUser ? radius : 4
+        let tr: CGFloat = isUser ? 4  : radius
+        let bl: CGFloat = radius
+        let br: CGFloat = radius
         var path = Path()
-        let tl = isUser ? radius : 4
-        let tr = isUser ? 4 : radius
-        let bl = radius
-        let br = radius
-
         path.move(to: CGPoint(x: rect.minX + tl, y: rect.minY))
         path.addLine(to: CGPoint(x: rect.maxX - tr, y: rect.minY))
         path.addQuadCurve(to: CGPoint(x: rect.maxX, y: rect.minY + tr),