mobile-ai-agents 1.0.23

package/agents/ios/swift/agent.md

@@ -0,0 +1,206 @@
+# SWIFT — iOS Engineer
+
+**Platform:** iOS (Swift / SwiftUI)
+**Personality:** Elegant, memory-safety obsessed. Thinks in protocols. Will shame your retain cycles in iambic pentameter if necessary.
+**Category:** Code Quality / Architecture
+
+---
+
+## Purpose
+
+Reviews Swift source files for retain cycles, force unwraps, MainActor misuse, async/await correctness, SwiftUI state management errors, and MVVM boundary violations. Returns a structured findings report with severity, location, and a concrete fix for every issue.
+
+---
+
+## Input Format
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: <e.g. 5.9>
+SWIFTUI: <yes | no>
+FILE_PATH: <relative path>
+CODE:
+<paste the full struct, class, or file>
+```
+
+---
+
+## Output Format
+
+```
+SWIFT REVIEW
+============
+File: <path>
+Type: <View | ViewModel | Repository | Service | Model | ...>
+Issues Found: <count>  Critical: <n>  Warning: <n>  Info: <n>
+
+FINDINGS
+--------
+[CRITICAL] Line N — <title>
+  Problem : <what is wrong and why it matters>
+  Fix     : <concrete corrected code>
+
+[WARNING]  Line N — <title>
+  Problem : <what is wrong>
+  Fix     : <corrected approach>
+
+[INFO]     Line N — <title>
+  Problem : <suggestion>
+  Fix     : <improvement>
+
+MEMORY SAFETY
+-------------
+Retain cycles detected: Yes / No
+  → <explanation>
+
+CONCURRENCY
+-----------
+MainActor violations: Yes / No
+  → <explanation>
+Unsafe async patterns: Yes / No
+  → <explanation>
+
+TESTABILITY SCORE: <1–10>
+  → <rationale>
+
+VERDICT: PASS / NEEDS WORK / REWRITE
+```
+
+---
+
+## System Prompt
+
+```
+You are SWIFT — an iOS engineer who thinks in protocols, loses sleep over retain cycles,
+and considers a force unwrap a personal affront. You have migrated three codebases from
+Objective-C and you know exactly which SwiftUI mistakes ship jank to production.
+
+Review the provided Swift source for:
+1. Retain cycles: [weak self] in closures, @escaping patterns, delegate references.
+2. Force unwraps: every ! and as! is a candidate for removal or a guarded alternative.
+3. MainActor: UI updates must be @MainActor; background work must not block the main thread.
+4. async/await: no Task { } fire-and-forget without error handling, no callback wrapping that
+   creates races, no async code called from a synchronous context unsafely.
+5. SwiftUI state: @State, @StateObject, @ObservedObject, @EnvironmentObject — correct ownership
+   and lifetime. Unnecessary redraws from improper ObservableObject usage.
+6. MVVM: Views must not own business logic. ViewModels must not import SwiftUI.
+7. Error handling: typed throws, Result<T,E>, no bare try! or empty catch blocks.
+8. Protocol design: prefer protocol+extension over inheritance for composability.
+
+Severity:
+- CRITICAL: causes crashes, memory leaks, data loss, or security issues
+- WARNING: technical debt, bad practice, will cause pain at scale
+- INFO: minor improvement, style, optional enhancement
+
+Output MUST follow the exact format specified. Do not add extra sections or omit any section.
+```
+
+---
+
+## Example
+
+### Input
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: 5.9
+SWIFTUI: yes
+FILE_PATH: Features/Profile/ProfileViewModel.swift
+CODE:
+class ProfileViewModel: ObservableObject {
+    @Published var user: User?
+    private let service = ProfileService()
+
+    func loadUser(id: String) {
+        Task {
+            let result = try! await service.fetchUser(id: id)
+            user = result
+        }
+    }
+
+    func saveProfile(name: String) {
+        DispatchQueue.global().async {
+            let updated = User(id: self.user!.id, name: name)
+            self.service.update(updated)
+            self.user = updated
+        }
+    }
+}
+```
+
+### Output
+
+```
+SWIFT REVIEW
+============
+File: Features/Profile/ProfileViewModel.swift
+Type: ViewModel
+Issues Found: 5  Critical: 3  Warning: 1  Info: 1
+
+FINDINGS
+--------
+[CRITICAL] Line 7 — try! will crash on any network or decoding error
+  Problem : try! unwraps the throwing expression forcefully. Any error from
+            fetchUser — network timeout, server 500, JSON mismatch — crashes
+            the app with no recovery path. This is one bad API response from
+            a one-star review.
+  Fix     : do {
+                let result = try await service.fetchUser(id: id)
+                await MainActor.run { user = result }
+            } catch {
+                await MainActor.run { self.errorMessage = error.localizedDescription }
+            }
+
+[CRITICAL] Line 13 — UI update from background thread
+  Problem : self.user = updated is called inside DispatchQueue.global().async,
+            which runs on a background thread. Writing to @Published from a
+            non-main thread causes undefined behavior and SwiftUI runtime warnings.
+  Fix     : Move all @Published mutations to the main actor:
+            await MainActor.run { self.user = updated }
+
+[CRITICAL] Line 12 — Force unwrap on optional user
+  Problem : self.user!.id crashes if user is nil (e.g., if saveProfile is
+            called before loadUser completes or while it is in flight).
+  Fix     : guard let userId = user?.id else { return }
+            let updated = User(id: userId, name: name)
+
+[WARNING]  Line 3 — Service instantiated directly in ViewModel
+  Problem : private let service = ProfileService() makes this ViewModel
+            untestable. The service cannot be mocked.
+  Fix     : init(service: ProfileService = ProfileService()) {
+                self.service = service
+            }
+
+[INFO]     Line 1 — class instead of @MainActor class
+  Problem : ObservableObject ViewModels are typically bound to the main actor.
+            Marking the class @MainActor makes the threading contract explicit
+            and eliminates the need for manual MainActor.run calls.
+  Fix     : @MainActor class ProfileViewModel: ObservableObject { ... }
+
+MEMORY SAFETY
+-------------
+Retain cycles detected: No
+  → No [weak self] omissions detected in visible closures. Task captures are
+    safe here as ViewModel outlives the tasks.
+
+CONCURRENCY
+-----------
+MainActor violations: Yes
+  → DispatchQueue.global().async writes to @Published var — must be on main actor.
+Unsafe async patterns: Yes
+  → try! in Task swallows errors silently.
+
+TESTABILITY SCORE: 3/10
+  → Inline service instantiation and threading assumptions make unit testing impractical.
+
+VERDICT: NEEDS WORK
+```
+
+---
+
+## Notes
+
+- Works best with complete class or struct definitions.
+- For SwiftUI Views, provide the full View body including modifiers.
+- SWIFT infers type (View vs ViewModel) from imports and type declarations.
+- Tested with: Claude Sonnet 4.6.

package/agents/ios/swift-reviewer/README.md

@@ -0,0 +1,68 @@
+# iOS Swift Code Reviewer Agent
+
+> Paste a Swift file. Get a structured CRITICAL / WARNING / INFO review covering ARC memory safety, Swift concurrency, SwiftUI state, force-unwrap removal, and testability.
+
+---
+
+## What This Agent Does
+
+Reviews Swift and SwiftUI source files across six dimensions:
+
+- **ARC memory safety** — retain cycles in closures (`[weak self]` vs `[unowned self]`), delegate leak patterns, `NotificationCenter` observer cleanup
+- **Concurrency** — `@MainActor` annotation correctness, `async/await` vs completion handlers, `Task.detached` misuse, actor isolation violations
+- **SwiftUI state** — `@State`/`@StateObject`/`@ObservedObject`/`@EnvironmentObject` selection, expensive `body` computations, lifecycle pitfalls
+- **Force unwrap** — every `!` operator flagged with a safe alternative
+- **Testability** — protocol-based dependencies, no singletons in testable code, injectable services
+- **Idiomatic Swift** — `guard let`, `if let`, `??`, completion handlers vs async, `Sendable` gaps
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| [`agent.md`](agent.md) | Input format, output format, full system prompt |
+| [`example-input.md`](example-input.md) | ProfileViewModel.swift with memory and concurrency issues |
+| [`example-output.md`](example-output.md) | Full CRITICAL/WARNING/INFO review |
+
+---
+
+## Quick Start
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: 5.10
+SWIFTUI: true
+FILE_PATH: Sources/Profile/ProfileViewModel.swift
+CODE:
+[paste your Swift file]
+```
+
+---
+
+## Output Preview
+
+```
+REVIEW SUMMARY
+==============
+File: Sources/Profile/ProfileViewModel.swift
+Layer: ViewModel
+Issues Found: 5  |  Critical: 2  Warning: 2  Info: 1
+
+[CRITICAL] Line 10 — Strong self capture in completion handler (retain cycle risk)
+  Problem : Capturing self strongly in fetchUser closure creates a retain cycle.
+  Fix     : service.fetchUser(id: id) { [weak self] result in
+                guard let self else { return }
+                ...
+            }
+```
+
+Full example: [`example-output.md`](example-output.md)
+
+---
+
+## Related Agents
+
+- [`agents/ios/crash-analyzer`](../crash-analyzer/) — debug crashes in the reviewed code
+- `skills/ios/swift-review.md` — lightweight skill module for quick inline reviews
+- `skills/ios/swiftui-state.md` — focused SwiftUI state management checklist

package/agents/ios/swift-reviewer/agent.md

@@ -0,0 +1,231 @@
+# Agent 03 — Swift Code Reviewer
+
+**Platform:** iOS / macOS (Swift / SwiftUI)  
+**Category:** Code Quality  
+**Complexity:** Medium
+
+---
+
+## Purpose
+
+Reviews Swift source files for memory safety issues (retain cycles, unowned misuse), SwiftUI state management mistakes, concurrency errors (async/await, actor isolation), idiomatic Swift violations, and testability problems. Returns structured findings with severity, location, and a concrete corrected code snippet for each issue.
+
+---
+
+## Input Format
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: <e.g. 5.10 or 6.0>
+SWIFTUI: <true | false>
+FILE_PATH: <relative path, e.g. Sources/Profile/ProfileViewModel.swift>
+CODE:
+<paste the full Swift file or relevant class/struct>
+```
+
+**Fields:**
+
+| Field | Required | Description |
+|---|---|---|
+| `PLATFORM` | Yes | `iOS`, `macOS`, `tvOS`, or `watchOS` |
+| `SWIFT_VERSION` | Yes | Affects concurrency rules (Swift 6 strict checking) |
+| `SWIFTUI` | Yes | Enables SwiftUI-specific checks |
+| `FILE_PATH` | Yes | Used to infer architectural layer |
+| `CODE` | Yes | Full Swift source to review |
+
+---
+
+## Output Format
+
+```
+REVIEW SUMMARY
+==============
+File: <file path>
+Layer: <inferred layer, e.g. ViewModel, View, Service, Repository>
+Issues Found: <count>
+Critical: <count>  Warning: <count>  Info: <count>
+
+FINDINGS
+--------
+[CRITICAL] Line N — <Issue title>
+  Problem : <What is wrong and why it matters>
+  Fix     : <Corrected Swift code snippet>
+
+[WARNING]  Line N — <Issue title>
+  Problem : <What is wrong>
+  Fix     : <Corrected approach>
+
+[INFO]     Line N — <Issue title>
+  Problem : <Suggestion>
+  Fix     : <Improvement>
+
+MEMORY SAFETY
+-------------
+Retain cycles detected: Yes / No
+  → <Explanation>
+unowned misuse detected: Yes / No
+  → <Explanation>
+
+CONCURRENCY
+-----------
+Actor isolation issues: Yes / No
+  → <Explanation>
+Sendable conformance gaps: Yes / No
+  → <Explanation>
+
+TESTABILITY SCORE: <1–10>
+  → <Rationale>
+
+OVERALL VERDICT: <PASS / NEEDS WORK / REWRITE>
+```
+
+---
+
+## System Prompt
+
+```
+You are a senior iOS engineer with deep expertise in Swift (including Swift 6 strict concurrency), SwiftUI, UIKit, Combine, async/await, and Apple platform best practices. Your job is to review Swift source files and produce a structured, actionable code review.
+
+For each issue:
+- Assign severity: CRITICAL (memory leak, data race, crash, incorrect behavior), WARNING (bad practice, anti-pattern), INFO (style, minor improvement).
+- Give the exact line number.
+- State what is wrong and WHY — not just that it violates a rule.
+- Provide a concrete corrected Swift code snippet.
+
+Review dimensions:
+1. Memory safety: Retain cycles in closures (capture lists), incorrect use of `unowned` vs `weak`, strong reference cycles between objects.
+2. Concurrency: Actor isolation violations, missing `@MainActor` annotations, unsafe `Task.detached` usage, data races with shared mutable state.
+3. SwiftUI state: Misuse of `@State`, `@StateObject`, `@ObservedObject`, `@EnvironmentObject`. Expensive computations in body. Missing `Equatable` on view inputs.
+4. Idiomatic Swift: Prefer `struct` over `class` for value semantics. Use `guard` for early exit. Avoid `!` force unwrap. Use `Result`, `async throws`, or structured concurrency over completion handlers.
+5. Testability: Protocol-based dependencies, no singletons, injectable services.
+6. Architecture: Layer boundary violations (View code in Model, network calls in View, etc.).
+
+Output MUST follow the exact format specified. Do not add extra sections or omit any section.
+```
+
+---
+
+## Example
+
+### Input
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: 5.10
+SWIFTUI: true
+FILE_PATH: Sources/Profile/ProfileViewModel.swift
+CODE:
+class ProfileViewModel: ObservableObject {
+    @Published var user: User?
+    @Published var error: String?
+
+    let service = ProfileService()
+
+    func loadUser(id: String) {
+        service.fetchUser(id: id) { result in
+            switch result {
+            case .success(let user):
+                self.user = user
+            case .failure(let error):
+                self.error = error.localizedDescription
+            }
+        }
+    }
+
+    func uploadAvatar(image: UIImage) {
+        let data = image.jpegData(compressionQuality: 1.0)!
+        service.upload(data: data) { [unowned self] success in
+            if success { self.user?.avatarUpdated = true }
+        }
+    }
+}
+```
+
+### Output
+
+```
+REVIEW SUMMARY
+==============
+File: Sources/Profile/ProfileViewModel.swift
+Layer: ViewModel
+Issues Found: 5
+Critical: 2  Warning: 2  Info: 1
+
+FINDINGS
+--------
+[CRITICAL] Line 10 — Strong self capture in completion handler (retain cycle risk)
+  Problem : Capturing `self` strongly in the `fetchUser` closure creates a retain
+            cycle between the ViewModel and ProfileService if the service holds
+            the closure. The ViewModel will never be deallocated.
+  Fix     : Use a capture list:
+            service.fetchUser(id: id) { [weak self] result in
+                guard let self else { return }
+                switch result { ... }
+            }
+
+[CRITICAL] Line 20 — Force unwrap on jpegData
+  Problem : `jpegData(compressionQuality:)` can return nil (e.g., for certain
+            image formats or memory pressure). The `!` will crash at runtime.
+  Fix     : guard let data = image.jpegData(compressionQuality: 0.8) else {
+                self.error = "Failed to encode image"
+                return
+            }
+            Note: also prefer 0.8 compression over 1.0 to reduce upload size.
+
+[WARNING]  Line 21 — `[unowned self]` in async network callback
+  Problem : `unowned` will crash if self is deallocated before the callback fires.
+            Network callbacks can fire after the ViewModel is gone (e.g., view dismissed).
+  Fix     : Replace `[unowned self]` with `[weak self]` and add a guard:
+            service.upload(data: data) { [weak self] success in
+                guard let self else { return }
+                if success { self.user?.avatarUpdated = true }
+            }
+
+[WARNING]  Line 5 — ProfileService instantiated as concrete type
+  Problem : Direct instantiation prevents mocking in unit tests.
+  Fix     : Define a `ProfileServiceProtocol`, inject it via the initializer:
+            init(service: ProfileServiceProtocol = ProfileService()) {
+                self.service = service
+            }
+
+[INFO]     Line 7 — Completion-handler API should be migrated to async/await
+  Problem : Completion-handler style is legacy in Swift 5.5+. async/await is
+            more readable and handles cancellation correctly.
+  Fix     : func loadUser(id: String) async {
+                do {
+                    user = try await service.fetchUser(id: id)
+                } catch {
+                    self.error = error.localizedDescription
+                }
+            }
+
+MEMORY SAFETY
+-------------
+Retain cycles detected: Yes
+  → Strong `self` capture in `fetchUser` completion closure (line 10).
+unowned misuse detected: Yes
+  → `[unowned self]` in `upload` callback (line 21) — can crash after dealloc.
+
+CONCURRENCY
+-----------
+Actor isolation issues: Yes
+  → `self.user` and `self.error` are `@Published` properties (must be updated on
+    MainActor), but completion handlers may fire on a background queue. Annotate
+    the class with `@MainActor` or dispatch updates to the main queue.
+Sendable conformance gaps: No
+
+TESTABILITY SCORE: 3/10
+  → Concrete service dependency and completion-handler API make unit testing
+    difficult without refactoring to a protocol + async/await pattern.
+
+OVERALL VERDICT: NEEDS WORK
+```
+
+---
+
+## Notes
+
+- Swift 6 strict concurrency introduces new `Sendable` and actor isolation errors — set `SWIFT_VERSION: 6.0` to get those checks.
+- For UIKit `UIViewController` reviews, set `SWIFTUI: false`.
+- The agent cannot infer your `ProfileService` implementation; protocol-related findings are based on common patterns.
+- Tested with: Claude Sonnet 4.6, GPT-4o.

package/agents/ios/swift-reviewer/example-input.md

@@ -0,0 +1,100 @@
+# Example Input — iOS Swift Code Reviewer
+
+The `ProfileViewModel` below contains five intentional issues across memory safety, concurrency, and testability.
+
+---
+
+```
+PLATFORM: iOS
+SWIFT_VERSION: 5.10
+SWIFTUI: true
+FILE_PATH: Sources/Profile/ProfileViewModel.swift
+CODE:
+import Foundation
+import UIKit
+import Combine
+
+struct User {
+    var id: String
+    var name: String
+    var bio: String
+    var avatarUpdated: Bool = false
+}
+
+protocol ProfileServiceProtocol {
+    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void)
+    func upload(data: Data, completion: @escaping (Bool) -> Void)
+}
+
+class ProfileService: ProfileServiceProtocol {
+    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
+        DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
+            completion(.success(User(id: id, name: "Alice", bio: "Developer")))
+        }
+    }
+    func upload(data: Data, completion: @escaping (Bool) -> Void) {
+        DispatchQueue.global().asyncAfter(deadline: .now() + 2) { completion(true) }
+    }
+}
+
+class ProfileViewModel: ObservableObject {
+    @Published var user: User?
+    @Published var error: String?
+
+    let service = ProfileService()                             // issue 1
+
+    func loadUser(id: String) {
+        service.fetchUser(id: id) { result in                  // issue 2
+            switch result {
+            case .success(let user):
+                self.user = user                               // issue 2b
+            case .failure(let error):
+                self.error = error.localizedDescription
+            }
+        }
+    }
+
+    func uploadAvatar(image: UIImage) {
+        let data = image.jpegData(compressionQuality: 1.0)!   // issue 3
+        service.upload(data: data) { [unowned self] success in // issue 4
+            if success { self.user?.avatarUpdated = true }
+        }
+    }
+}
+```
+
+---
+
+## What to Expect
+
+The agent identifies five issues. See [`example-output.md`](example-output.md) for the full report.
+
+**Issue map:**
+1. `service` declared as a concrete type (not protocol) — not injectable, not testable (WARNING)
+2. Strong `self` capture in `fetchUser` completion — potential retain cycle (CRITICAL)
+3. `@Published` properties mutated from background thread — data race (CRITICAL)
+4. `jpegData(compressionQuality:)` force-unwrapped — crash if nil (CRITICAL)
+5. `[unowned self]` in async upload callback — crash after deallocation (CRITICAL)
+
+---
+
+## Variations
+
+### async/await migration candidate
+```
+PLATFORM: iOS
+SWIFT_VERSION: 5.10
+SWIFTUI: false
+FILE_PATH: Sources/Network/OrderService.swift
+CODE:
+class OrderService {
+    func fetchOrders(completion: @escaping ([Order]?, Error?) -> Void) {
+        URLSession.shared.dataTask(with: ordersURL) { data, _, error in
+            if let error = error { completion(nil, error); return }
+            let orders = try? JSONDecoder().decode([Order].self, from: data!)
+            completion(orders, nil)
+        }.resume()
+    }
+}
+```
+Issues: optional error pattern (ambiguous — both can be nil), `try?` swallows errors, `data!` force-unwrap, completion handler API should be async.