@nockdev/awf 6.2.0

package/.agent/skills/languages/swift/ADVANCED.md

@@ -0,0 +1,231 @@
+# Swift — Advanced Patterns
+
+# DOMYH Awesome Code — Tier 3 Reference
+
+## Table of Contents
+
+- [Concurrency](#concurrency)
+- [Protocols & Generics](#protocols--generics)
+- [Memory Management](#memory-management)
+- [SwiftUI Patterns](#swiftui-patterns)
+
+---
+
+## Concurrency
+
+### Async/Await
+
+```swift
+func fetchUserData(userId: String) async throws -> UserData {
+    async let profile = fetchProfile(userId)
+    async let orders = fetchOrders(userId)
+    async let settings = fetchSettings(userId)
+
+    return try await UserData(
+        profile: profile,
+        orders: orders,
+        settings: settings
+    )
+}
+
+// Actor for thread safety
+actor OrderCache {
+    private var cache: [String: Order] = [:]
+
+    func get(_ id: String) -> Order? {
+        return cache[id]
+    }
+
+    func set(_ id: String, order: Order) {
+        cache[id] = order
+    }
+}
+```
+
+### TaskGroup
+
+```swift
+func processAllOrders(_ ids: [String]) async throws -> [Result] {
+    try await withThrowingTaskGroup(of: Result.self) { group in
+        for id in ids {
+            group.addTask {
+                try await processOrder(id)
+            }
+        }
+
+        var results: [Result] = []
+        for try await result in group {
+            results.append(result)
+        }
+        return results
+    }
+}
+```
+
+---
+
+## Protocols & Generics
+
+### Protocol with Associated Types
+
+```swift
+protocol Repository {
+    associatedtype Entity
+    associatedtype ID: Hashable
+
+    func find(by id: ID) async throws -> Entity?
+    func save(_ entity: Entity) async throws
+    func delete(by id: ID) async throws
+}
+
+struct UserRepository: Repository {
+    typealias Entity = User
+    typealias ID = UUID
+
+    func find(by id: UUID) async throws -> User? {
+        // Implementation
+    }
+}
+```
+
+### Type Erasure
+
+```swift
+// Type-erased wrapper
+struct AnyRepository<Entity, ID: Hashable>: Repository {
+    private let _find: (ID) async throws -> Entity?
+    private let _save: (Entity) async throws -> Void
+
+    init<R: Repository>(_ repository: R) where R.Entity == Entity, R.ID == ID {
+        _find = repository.find
+        _save = repository.save
+    }
+
+    func find(by id: ID) async throws -> Entity? {
+        try await _find(id)
+    }
+
+    func save(_ entity: Entity) async throws {
+        try await _save(entity)
+    }
+}
+```
+
+---
+
+## Memory Management
+
+### Weak References in Closures
+
+```swift
+class ViewModel {
+    private var cancellables = Set<AnyCancellable>()
+
+    func fetchData() {
+        dataService.fetch()
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] completion in
+                guard let self = self else { return }
+                self.handleCompletion(completion)
+            } receiveValue: { [weak self] data in
+                self?.processData(data)
+            }
+            .store(in: &cancellables)
+    }
+}
+```
+
+### Unowned for Performance
+
+```swift
+class Parent {
+    lazy var child: Child = {
+        // Guaranteed to outlive child - use unowned
+        Child(parent: self)
+    }()
+}
+
+class Child {
+    unowned let parent: Parent
+
+    init(parent: Parent) {
+        self.parent = parent
+    }
+}
+```
+
+---
+
+## SwiftUI Patterns
+
+### MVVM with Combine
+
+```swift
+@MainActor
+class OrderViewModel: ObservableObject {
+    @Published private(set) var orders: [Order] = []
+    @Published private(set) var isLoading = false
+    @Published var error: Error?
+
+    private let repository: OrderRepository
+
+    init(repository: OrderRepository) {
+        self.repository = repository
+    }
+
+    func loadOrders() async {
+        isLoading = true
+        defer { isLoading = false }
+
+        do {
+            orders = try await repository.fetchAll()
+        } catch {
+            self.error = error
+        }
+    }
+}
+
+struct OrderListView: View {
+    @StateObject private var viewModel: OrderViewModel
+
+    var body: some View {
+        List(viewModel.orders) { order in
+            OrderRow(order: order)
+        }
+        .task {
+            await viewModel.loadOrders()
+        }
+    }
+}
+```
+
+### Environment & Dependency Injection
+
+```swift
+// Environment key
+struct RepositoryKey: EnvironmentKey {
+    static var defaultValue: OrderRepository = MockOrderRepository()
+}
+
+extension EnvironmentValues {
+    var orderRepository: OrderRepository {
+        get { self[RepositoryKey.self] }
+        set { self[RepositoryKey.self] = newValue }
+    }
+}
+
+// Usage
+@main
+struct MyApp: App {
+    var body: some Scene {
+        WindowGroup {
+            ContentView()
+                .environment(\.orderRepository, ProductionOrderRepository())
+        }
+    }
+}
+```
+
+---
+
+_DOMYH Awesome Code — Tier 3 Reference_

package/.agent/skills/languages/swift/META.yaml

@@ -0,0 +1,18 @@
+name: swift
+version: "6.0.0"
+category: languages
+tier: 3
+
+domains:
+  core: 5
+
+desc: "Apple platform development patterns for Swift 6/6.1. Covers SwiftUI, async/await, actors, SwiftData."
+
+related_skills:
+  - flutter
+  - kotlin
+
+prevent_confusion_with:
+  - kotlin: "Swift is for Apple, Kotlin for Android"
+  - javascript: "Swift uses var/let differently than JS"
+  - rust: "Swift has ARC, Rust has ownership"

package/.agent/skills/languages/swift/SKILL.md

@@ -0,0 +1,342 @@
+---
+name: swift
+detect: ["Package.swift", "*.swift", "*.xcodeproj", "*.xcworkspace"]
+version: "6.1.2"
+category: mobile
+tier: 1
+---
+
+# Swift Patterns — DOMYH Awesome Code
+
+> **Version**: Swift 6/6.1 (2025-2026)
+> **Frameworks**: SwiftUI, UIKit
+> **Philosophy**: Protocol-oriented, type-safe, actor-based concurrency
+
+---
+
+## 🎯 When to Use This Skill
+
+Use for: iOS/macOS/watchOS/tvOS apps, SwiftUI, server-side Swift.
+**NOT for**: Android (→ kotlin), cross-platform (→ flutter).
+
+---
+
+## 📦 Recommended Stack (2025-2026)
+
+### UI Frameworks
+
+| Library     | Use Case             | iOS Version |
+| ----------- | -------------------- | ----------- |
+| **SwiftUI** | Declarative UI 🏆    | iOS 17+     |
+| **UIKit**   | Legacy, fine control | iOS 13+     |
+
+### Networking
+
+| Library        | Use Case              |
+| -------------- | --------------------- |
+| **URLSession** | Native async/await 🏆 |
+| **Alamofire**  | HTTP client           |
+
+### State & Data
+
+| Library         | Use Case             | iOS     |
+| --------------- | -------------------- | ------- |
+| **@Observable** | Observation macro 🏆 | iOS 17+ |
+| **SwiftData**   | Persistence          | iOS 17+ |
+| **Core Data**   | Legacy persistence   | iOS 13+ |
+| **Combine**     | Reactive streams     | iOS 13+ |
+
+### Architecture
+
+| Library  | Use Case                |
+| -------- | ----------------------- |
+| **TCA**  | Composable Architecture |
+| **MVVM** | ViewModels pattern      |
+
+### IDE Support
+
+| IDE          | Features                           |
+| ------------ | ---------------------------------- |
+| **Xcode 17** | Full Swift 6 support, AI assist 🏆 |
+| **VS Code**  | Swift extension, debugging         |
+
+---
+
+## 🆕 Swift 6 Features (2025)
+
+### Strict Concurrency (Data Race Safety)
+
+```swift
+// ✅ Swift 6 enforces data race safety at compile time
+// All sendable violations are now errors, not warnings
+
+actor UserCache {
+    private var cache: [Int: User] = [:]
+
+    func get(_ id: Int) -> User? {
+        cache[id]
+    }
+
+    func set(_ id: Int, user: User) {
+        cache[id] = user
+    }
+}
+
+// ✅ Sendable types can cross actor boundaries
+struct User: Sendable, Codable, Identifiable {
+    let id: Int
+    let name: String
+    let email: String
+}
+```
+
+### Async/Await Best Practices
+
+```swift
+// ✅ Structured concurrency with TaskGroup
+func fetchAllUsers(ids: [Int]) async throws -> [User] {
+    try await withThrowingTaskGroup(of: User?.self) { group in
+        for id in ids {
+            group.addTask {
+                try? await fetchUser(id: id)
+            }
+        }
+
+        var users: [User] = []
+        for try await user in group {
+            if let user { users.append(user) }
+        }
+        return users
+    }
+}
+
+// ✅ MainActor for UI updates
+@MainActor
+class UserViewModel: ObservableObject {
+    @Published var users: [User] = []
+    @Published var isLoading = false
+
+    func loadUsers() async {
+        isLoading = true
+        defer { isLoading = false }
+
+        do {
+            users = try await api.fetchUsers()
+        } catch {
+            // Handle error
+        }
+    }
+}
+```
+
+### @Observable Macro (iOS 17+)
+
+```swift
+import Observation
+
+// ✅ Modern observation - replaces ObservableObject
+@Observable
+class UserStore {
+    var users: [User] = []
+    var selectedUser: User?
+    var isLoading = false
+
+    func load() async {
+        isLoading = true
+        users = await api.fetchUsers()
+        isLoading = false
+    }
+}
+
+// ✅ Usage in SwiftUI
+struct UserListView: View {
+    @State private var store = UserStore()
+
+    var body: some View {
+        List(store.users) { user in
+            UserRow(user: user)
+        }
+        .task { await store.load() }
+    }
+}
+```
+
+---
+
+## 🎨 SwiftUI Best Practices
+
+### View Composition
+
+```swift
+// ✅ Small, focused components
+struct UserRow: View {
+    let user: User
+
+    var body: some View {
+        HStack {
+            AsyncImage(url: user.avatarURL) { image in
+                image.resizable()
+            } placeholder: {
+                ProgressView()
+            }
+            .frame(width: 40, height: 40)
+            .clipShape(Circle())
+
+            VStack(alignment: .leading) {
+                Text(user.name).font(.headline)
+                Text(user.email).font(.caption).foregroundStyle(.secondary)
+            }
+        }
+    }
+}
+```
+
+### Navigation (iOS 16+)
+
+```swift
+// ✅ Type-safe navigation with NavigationStack
+struct ContentView: View {
+    @State private var path = NavigationPath()
+
+    var body: some View {
+        NavigationStack(path: $path) {
+            UserListView(path: $path)
+                .navigationDestination(for: User.self) { user in
+                    UserDetailView(user: user)
+                }
+        }
+    }
+}
+```
+
+### State Management
+
+```swift
+// ✅ @State for local, @Binding for passing down
+struct ToggleView: View {
+    @Binding var isOn: Bool
+
+    var body: some View {
+        Toggle("Enable", isOn: $isOn)
+    }
+}
+
+// ✅ @Environment for dependency injection
+@Observable
+class AuthManager {
+    var currentUser: User?
+}
+
+struct ProfileView: View {
+    @Environment(AuthManager.self) private var auth
+
+    var body: some View {
+        if let user = auth.currentUser {
+            Text(user.name)
+        }
+    }
+}
+```
+
+---
+
+## 🔧 SwiftData (iOS 17+)
+
+```swift
+import SwiftData
+
+// ✅ Model definition
+@Model
+class Task {
+    var title: String
+    var isCompleted: Bool
+    var createdAt: Date
+
+    init(title: String) {
+        self.title = title
+        self.isCompleted = false
+        self.createdAt = .now
+    }
+}
+
+// ✅ Usage in SwiftUI
+struct TaskListView: View {
+    @Environment(\.modelContext) private var context
+    @Query(sort: \Task.createdAt, order: .reverse) private var tasks: [Task]
+
+    var body: some View {
+        List(tasks) { task in
+            TaskRow(task: task)
+        }
+    }
+
+    func addTask(_ title: String) {
+        let task = Task(title: title)
+        context.insert(task)
+    }
+}
+```
+
+---
+
+## 🛡️ Error Handling
+
+```swift
+// ✅ Typed throws (Swift 6)
+enum NetworkError: Error, LocalizedError {
+    case invalidURL
+    case noData
+    case decodingFailed
+
+    var errorDescription: String? {
+        switch self {
+        case .invalidURL: "Invalid URL"
+        case .noData: "No data received"
+        case .decodingFailed: "Failed to decode response"
+        }
+    }
+}
+
+func fetchUser(id: Int) async throws(NetworkError) -> User {
+    guard let url = URL(string: "\(baseURL)/users/\(id)") else {
+        throw .invalidURL
+    }
+
+    let (data, _) = try await URLSession.shared.data(from: url)
+
+    do {
+        return try JSONDecoder().decode(User.self, from: data)
+    } catch {
+        throw .decodingFailed
+    }
+}
+```
+
+---
+
+## ✅ Best Practices Checklist
+
+### Code Quality
+
+- [ ] Swift 6 language mode enabled
+- [ ] Strict concurrency checking
+- [ ] SwiftLint configured
+- [ ] All types Sendable where needed
+
+### Architecture
+
+- [ ] @Observable for iOS 17+
+- [ ] MVVM or TCA pattern
+- [ ] Small, composable views
+- [ ] @MainActor for UI
+
+### Performance
+
+- [ ] Lazy loading for lists
+- [ ] AsyncImage for remote images
+- [ ] Proper task cancellation
+- [ ] EquatableView for complex views
+
+---
+
+_DOMYH Awesome Code • Swift 6/6.1_