swift-code-reviewer-skill 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -157,6 +157,12 @@ Provided complete examples for:
 - File-specific reviews
 - Multi-file reviews
 
+## [1.1.0] - 2026-03-16
+
+### Added
+
+- increase adjusts from Dimillian skill and more scenarios to cover
+
 ## [Unreleased]
 
 ### Planned Features
@@ -181,6 +187,7 @@ Provided complete examples for:
 
 ## Version History Summary
 
+- **1.1.0** (2026-03-16): Increase adjusts from Dimillian skill and more scenarios to cover
 - **1.0.0** (2026-02-10): Initial release with comprehensive review capabilities
 
 ---

package/README.md

@@ -1,5 +1,7 @@
 # Swift Code Reviewer Agent Skill
 
+[![GitHub Sponsors](https://img.shields.io/github/sponsors/Viniciuscarvalho?style=social)](https://github.com/sponsors/Viniciuscarvalho)
+
 A comprehensive code review skill for Claude that performs multi-layer analysis of Swift and SwiftUI code, combining Apple's best practices with project-specific coding standards.
 
 ## Features
@@ -14,6 +16,7 @@ A comprehensive code review skill for Claude that performs multi-layer analysis
 ## What It Reviews
 
 ### Swift Quality
+
 - **Concurrency Safety**: Actor isolation, MainActor usage, Sendable conformance, data race prevention
 - **Error Handling**: Typed throws, Result types, proper error propagation
 - **Optionals**: Safe unwrapping, guard statements, no force unwraps
@@ -21,6 +24,7 @@ A comprehensive code review skill for Claude that performs multi-layer analysis
 - **Naming**: Swift API Design Guidelines compliance
 
 ### SwiftUI Patterns
+
 - **State Management**: @Observable, @State, @Binding, @Environment usage
 - **Property Wrappers**: Correct wrapper selection for each use case
 - **Modern APIs**: NavigationStack, .task, latest SwiftUI features
@@ -28,24 +32,28 @@ A comprehensive code review skill for Claude that performs multi-layer analysis
 - **Accessibility**: Labels, hints, Dynamic Type support
 
 ### Performance
+
 - **View Optimization**: Unnecessary updates, Equatable conformance
 - **ForEach Performance**: Stable identity, lazy loading
 - **Layout Efficiency**: GeometryReader usage, layout thrash
 - **Resource Management**: Image loading, memory leaks, async patterns
 
 ### Security & Safety
+
 - **Input Validation**: Sanitization, bounds checking, type safety
 - **Sensitive Data**: Keychain storage, biometric authentication, secure logging
 - **Network Security**: HTTPS enforcement, certificate pinning, API key protection
 - **Permissions**: Privacy descriptions, permission timing, graceful handling
 
 ### Architecture
+
 - **Pattern Compliance**: MVVM, MVI, TCA adherence
 - **Dependency Injection**: Constructor injection, protocol-based dependencies
 - **Code Organization**: File structure, MARK comments, logical grouping
 - **Testability**: Unit test coverage, mock usage, test structure
 
 ### Project Standards
+
 - **Custom Guidelines**: Validates against `.claude/CLAUDE.md` rules
 - **Design System**: Color palette, typography, spacing token usage
 - **Error Patterns**: Custom error type conformance
@@ -55,7 +63,7 @@ A comprehensive code review skill for Claude that performs multi-layer analysis
 
 ### Option 1: NPX (Recommended)
 
-The fastest way to install - no cloning required:
+The fastest way to install — always fetches the latest version, no cloning or manual updates required:
 
 ```bash
 npx swift-code-reviewer-skill
@@ -63,6 +71,8 @@ npx swift-code-reviewer-skill
 
 This automatically installs the skill to `~/.claude/skills/swift-code-reviewer-skill/`
 
+> **Tip:** Running `npx swift-code-reviewer-skill` again at any time will update to the latest version automatically.
+
 To uninstall:
 
 ```bash
@@ -81,6 +91,7 @@ git clone https://github.com/Viniciuscarvalho/swift-code-reviewer-skill.git ~/.c
 ### Option 3: Manual Installation
 
 1. Create the skill directory:
+
 ```bash
 mkdir -p ~/.claude/skills/swift-code-reviewer-skill/references
 ```
@@ -98,6 +109,8 @@ ls ~/.claude/skills/swift-code-reviewer-skill/
 
 ## Usage
 
+![Swift Code Reviewer in action](assets/demo.png)
+
 ### Basic Usage
 
 The skill automatically activates when you ask Claude to review Swift/SwiftUI code:
@@ -119,6 +132,7 @@ Review UserProfileView.swift
 ```
 
 **What it does:**
+
 1. Reads `.claude/CLAUDE.md` for project standards
 2. Analyzes the file against all quality dimensions
 3. Provides structured feedback with severity levels
@@ -131,6 +145,7 @@ Review my uncommitted changes
 ```
 
 **What it does:**
+
 1. Runs `git diff` to identify changes
 2. Analyzes modified files
 3. Focuses on changed lines for efficiency
@@ -143,6 +158,7 @@ Review PR #123
 ```
 
 **What it does:**
+
 1. Fetches PR details using `gh pr view 123`
 2. Gets diff using `gh pr diff 123`
 3. Reads all changed files for context
@@ -155,6 +171,7 @@ Review MR #456
 ```
 
 **What it does:**
+
 1. Fetches MR details using `glab mr view 456`
 2. Gets diff and changed files
 3. Performs multi-layer analysis
@@ -167,6 +184,7 @@ Review LoginViewModel.swift against our coding standards
 ```
 
 **What it does:**
+
 1. Reads `.claude/CLAUDE.md` and related architecture docs
 2. Extracts project-specific rules
 3. Validates code against both Apple and project standards
@@ -179,6 +197,7 @@ Review all ViewModels in the Features folder
 ```
 
 **What it does:**
+
 1. Finds all matching files
 2. Analyzes each against architecture patterns
 3. Provides file-by-file review
@@ -254,6 +273,7 @@ Generates a structured markdown report:
 # Code Review Report
 
 ## Summary
+
 - Files Reviewed: 5
 - Critical: 0
 - High: 2
@@ -266,15 +286,19 @@ Generates a structured markdown report:
 ### File: LoginView.swift
 
 #### ✅ Positive Feedback
+
 1. Excellent use of @Observable for state management
 
 #### 🟡 High Priority
+
 1. Force unwrap detected at line 89 (potential crash)
 
 #### 💡 Refactoring Suggestions
+
 1. Consider extracting login form into separate view
 
 ## Prioritized Action Items
+
 [Must fix, should fix, consider items]
 ```
 
@@ -282,27 +306,30 @@ Generates a structured markdown report:
 
 ### Severity Levels
 
-| Severity | Icon | Description | Response Time |
-|----------|------|-------------|---------------|
-| **Critical** | 🔴 | Security vulnerabilities, crashes, data races | Must fix before merge |
-| **High** | 🟡 | Performance issues, anti-patterns, major violations | Should fix before merge |
-| **Medium** | 🟠 | Code quality, documentation, minor violations | Fix in current sprint |
-| **Low** | 🔵 | Style, suggestions, minor improvements | Consider for future |
+| Severity     | Icon | Description                                         | Response Time           |
+| ------------ | ---- | --------------------------------------------------- | ----------------------- |
+| **Critical** | 🔴   | Security vulnerabilities, crashes, data races       | Must fix before merge   |
+| **High**     | 🟡   | Performance issues, anti-patterns, major violations | Should fix before merge |
+| **Medium**   | 🟠   | Code quality, documentation, minor violations       | Fix in current sprint   |
+| **Low**      | 🔵   | Style, suggestions, minor improvements              | Consider for future     |
 
 ### Feedback Types
 
 **Positive Feedback** ✅
+
 - Acknowledges good practices
 - Highlights excellent implementations
 - Recognizes proper patterns
 
 **Issues** 🔴🟡🟠🔵
+
 - File and line references
 - Code examples (before/after)
 - Specific fixes with explanations
 - Links to documentation
 
 **Refactoring Suggestions** 💡
+
 - Proactive improvements
 - Modernization opportunities
 - Code simplification ideas
@@ -321,32 +348,40 @@ The skill reads `.claude/CLAUDE.md` to understand your project's:
 
 ### Example .claude/CLAUDE.md
 
-```markdown
+````markdown
 # MyApp Coding Standards
 
 ## Architecture
+
 We use **MVVM with Coordinators**:
+
 - ViewModels MUST use @Observable (iOS 17+)
 - All dependencies MUST be injected via constructor
 - Views MUST NOT contain business logic
 
 ## Error Handling
+
 All errors MUST conform to AppError:
+
 ```swift
 protocol AppError: Error {
     var message: String { get }
     var code: Int { get }
 }
 ```
+````
 
 ## Design System
+
 - Use AppColors enum ONLY
 - Use AppFonts enum ONLY
 - Use AppSpacing for all padding
 
 ## Testing
+
 - Minimum coverage: 80%
 - All ViewModels MUST have unit tests
+
 ```
 
 The skill will validate your code against these standards and report violations.
@@ -391,8 +426,10 @@ For performance analysis
 
 **Input:**
 ```
+
 Review my uncommitted changes
-```
+
+````
 
 **Output:**
 ```markdown
@@ -419,23 +456,27 @@ Review my uncommitted changes
 Current Code:
 ```swift
 let user = repository.currentUser!
-```
+````
 
 Recommended Fix:
+
 ```swift
 guard let user = repository.currentUser else {
     logger.error("No current user")
     return
 }
 ```
+
 ```
 
 ### Example 2: Review Against Project Standards
 
 **Input:**
 ```
+
 Review LoginView.swift against our coding standards
-```
+
+````
 
 **Output:**
 ```markdown
@@ -454,14 +495,16 @@ Review LoginView.swift against our coding standards
 Current Code:
 ```swift
 .foregroundColor(.blue)  // ❌ Hardcoded
-```
+````
 
 Expected Code:
+
 ```swift
 .foregroundColor(AppColors.primary)  // ✅ Design system
 ```
 
 Reference: .claude/CLAUDE.md:Design System
+
 ```
 
 ## Requirements
@@ -534,3 +577,4 @@ MIT License - See [LICENSE](LICENSE) file for details
 **Made with ❤️ for the Swift community**
 
 If this skill helps improve your code reviews, please ⭐️ star the repository!
+```

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: swift-code-reviewer
-description: Perform thorough code reviews for Swift/SwiftUI code, analyzing code quality, architecture, performance, security, and adherence to Swift 6+ best practices, SwiftUI patterns, iOS/macOS platform guidelines, and project-specific coding standards from .claude/CLAUDE.md. Use when reviewing code changes, performing quality audits, or providing structured feedback on Swift codebases with all severity levels and positive feedback.
+description: Perform thorough code reviews for Swift/SwiftUI code, analyzing code quality, architecture, performance, security, and adherence to Swift 6+ best practices, SwiftUI patterns, navigation architecture, sheet routing, theming, async state, iOS/macOS platform guidelines, and project-specific coding standards from .claude/CLAUDE.md. Use when reviewing code changes, performing quality audits, or providing structured feedback on Swift codebases with all severity levels and positive feedback.
 ---
 
 # Swift/SwiftUI Code Review Skill
@@ -389,6 +389,23 @@ This skill **references** (not duplicates) three foundational skills for domain
 - Reference performance-specific checks when reviewing view code
 - Apply recommendations from the skill to performance-sensitive paths
 
+### 4. swiftui-ui-patterns
+**When to Use:** Reviewing navigation architecture, sheet/modal routing, TabView setup, theming, async state management, focus handling, or API client patterns
+
+**What it Provides:**
+- Navigation architecture (route enums, RouterPath, centralized navigationDestination)
+- Sheet/modal routing (item-driven sheets, SheetDestination enum)
+- TabView with independent per-tab navigation history
+- Theming with semantic colors via `@Environment(Theme.self)`
+- Async state patterns (`.task(id:)`, LoadState enum, CancellationError handling)
+- Focus chaining with FocusField enum and `.onSubmit`
+- Lightweight API client pattern (closure-based structs, `.live()` / `.mock()` factories)
+
+**How to Leverage:**
+- Read `~/.claude/skills/swiftui-ui-patterns/references/navigation.md` for route enum and RouterPath checks
+- Reference `sheets-modals.md` for sheet routing validation
+- Use `theming.md` for semantic color enforcement
+
 **Integration Strategy:**
 1. Load relevant reference files from these skills as needed
 2. Apply their checklist items to the review
@@ -619,6 +636,29 @@ Steps:
 5. Summarize common patterns and issues across all files
 ```
 
+### Example 6: Review Navigation / Routing Code
+```
+User: "Review our navigation setup and routing code"
+
+Steps:
+1. Read .claude/CLAUDE.md for project navigation patterns
+2. Read router/coordinator files (RouterPath, AppCoordinator, TabRouter)
+3. Read root views that set up NavigationStack and TabView
+4. Run navigation architecture checks:
+   - Route destinations use typed Hashable enum (not String/Int)
+   - RouterPath @Observable owns path (not ad-hoc @State)
+   - Single centralized .navigationDestination per stack
+   - .sheet(item:) preferred over .sheet(isPresented:) when model selected
+   - Multiple sheets use SheetDestination enum (not multiple booleans)
+   - Each tab has independent RouterPath (not shared)
+   - .onOpenURL at app root, not scattered in feature views
+5. Run async state checks:
+   - .task(id:) for input-driven async work
+   - CancellationError silenced
+   - LoadState<T> enum instead of multiple booleans
+6. Generate report with navigation-specific findings
+```
+
 ## Resources
 
 This skill includes the following reference materials:
@@ -685,6 +725,6 @@ For runtime analysis, recommend using Instruments or other profiling tools.
 
 ## Version
 
-**Version**: 1.0.0
-**Last Updated**: 2026-02-10
+**Version**: 1.1.0
+**Last Updated**: 2026-03-16
 **Compatible with**: Swift 6+, SwiftUI (iOS 17+, macOS 14+, watchOS 10+, tvOS 17+, visionOS 1+)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swift-code-reviewer-skill",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Claude Code skill for comprehensive Swift/SwiftUI code reviews with multi-layer analysis",
   "keywords": [
     "claude",

package/references/architecture-patterns.md

@@ -593,6 +593,281 @@ struct UserListView: View {
 
 ---
 
+## 5A. Lightweight Client Pattern (Closure-Based)
+
+### 5A.1 Overview
+
+**Purpose**: Define API clients as value-type structs with async closure properties, enabling easy swapping between live and mock implementations — especially for SwiftUI previews.
+
+**Benefits:**
+- Preview-friendly (no network calls in Xcode Previews)
+- Testable without subclassing or protocol mocking boilerplate
+- Composable: clients can be scoped per-feature
+- No shared mutable singleton state
+
+### 5A.2 Implementation Pattern
+
+**Check for:**
+- [ ] API client defined as a `struct` with `async` closure properties (not a singleton class)
+- [ ] Static factory `.live(baseURL:)` for production
+- [ ] Static factory `.mock(...)` for previews and tests
+- [ ] Store (`@Observable`) holds the client; views never call the client directly
+- [ ] Client injected via `@Environment` or constructor
+
+**Examples:**
+
+❌ **Bad: Singleton class client**
+```swift
+final class UserAPIClient {
+    static let shared = UserAPIClient()  // ❌ Singleton — untestable, preview-unfriendly
+
+    func fetchUser(id: UUID) async throws -> User {
+        let url = URL(string: "https://api.example.com/users/\(id)")!
+        let (data, _) = try await URLSession.shared.data(from: url)
+        return try JSONDecoder().decode(User.self, from: data)
+    }
+}
+
+final class UserViewModel {
+    func loadUser(id: UUID) async {
+        let user = try await UserAPIClient.shared.fetchUser(id: id)  // ❌ Hard dependency
+    }
+}
+```
+
+✅ **Good: Struct with closure properties**
+```swift
+// Client defined as a struct with closure properties
+struct UserAPIClient {
+    var fetchUser: (UUID) async throws -> User
+    var updateUser: (User) async throws -> User
+    var deleteUser: (UUID) async throws -> Void
+}
+
+// Live implementation
+extension UserAPIClient {
+    static func live(baseURL: URL) -> Self {
+        UserAPIClient(
+            fetchUser: { id in
+                let url = baseURL.appendingPathComponent("users/\(id)")
+                let (data, _) = try await URLSession.shared.data(from: url)
+                return try JSONDecoder().decode(User.self, from: data)
+            },
+            updateUser: { user in
+                var request = URLRequest(url: baseURL.appendingPathComponent("users/\(user.id)"))
+                request.httpMethod = "PUT"
+                request.httpBody = try JSONEncoder().encode(user)
+                let (data, _) = try await URLSession.shared.data(for: request)
+                return try JSONDecoder().decode(User.self, from: data)
+            },
+            deleteUser: { id in
+                var request = URLRequest(url: baseURL.appendingPathComponent("users/\(id)"))
+                request.httpMethod = "DELETE"
+                _ = try await URLSession.shared.data(for: request)
+            }
+        )
+    }
+}
+
+// Mock implementation for previews and tests
+extension UserAPIClient {
+    static func mock(
+        fetchUser: @escaping (UUID) async throws -> User = { _ in .mock },
+        updateUser: @escaping (User) async throws -> User = { $0 },
+        deleteUser: @escaping (UUID) async throws -> Void = { _ in }
+    ) -> Self {
+        UserAPIClient(
+            fetchUser: fetchUser,
+            updateUser: updateUser,
+            deleteUser: deleteUser
+        )
+    }
+}
+
+// Store holds the client — views never call it directly
+@MainActor
+@Observable
+final class UserStore {
+    private let client: UserAPIClient
+    private(set) var user: User?
+    private(set) var isLoading = false
+
+    init(client: UserAPIClient) {
+        self.client = client
+    }
+
+    func loadUser(id: UUID) async {
+        isLoading = true
+        defer { isLoading = false }
+        user = try? await client.fetchUser(id)
+    }
+}
+
+// View uses Store, not Client directly
+struct UserProfileView: View {
+    let store: UserStore
+
+    var body: some View {
+        Group {
+            if let user = store.user {
+                Text(user.name)
+            } else {
+                ProgressView()
+            }
+        }
+        .task { await store.loadUser(id: userID) }
+    }
+}
+
+// Preview uses mock client
+#Preview {
+    UserProfileView(store: UserStore(client: .mock(
+        fetchUser: { _ in User(id: UUID(), name: "Preview User") }
+    )))
+}
+
+// App uses live client
+@main
+struct MyApp: App {
+    let userStore = UserStore(client: .live(baseURL: URL(string: "https://api.example.com")!))
+
+    var body: some Scene {
+        WindowGroup {
+            UserProfileView(store: userStore)
+        }
+    }
+}
+```
+
+---
+
+## 5B. Per-Tab Navigation Architecture
+
+### 5B.1 Overview
+
+**Purpose**: Provide each tab with its own independent navigation stack and router, preserving navigation history across tab switches and supporting deep link routing to a specific tab.
+
+**Benefits:**
+- Tab navigation state preserved when switching tabs (native iOS behavior)
+- Deep links can target specific tabs without resetting all stacks
+- Decoupled tab-specific routing logic
+
+### 5B.2 Implementation Pattern
+
+**Check for:**
+- [ ] `TabRouter` (or `AppTabRouter`) owns one `RouterPath` per tab
+- [ ] `Binding(for tab:)` helper creates a `Binding<[Route]>` for each tab's stack
+- [ ] Deep links dispatched to the correct tab's router (not a global path)
+- [ ] Tab switching does not reset other tabs' navigation stacks
+
+**Examples:**
+
+❌ **Bad: Single shared path for all tabs**
+```swift
+struct MainTabView: View {
+    @State private var path = NavigationPath()  // ❌ Shared — tab switch loses history
+    @State private var selectedTab = 0
+
+    var body: some View {
+        TabView(selection: $selectedTab) {
+            NavigationStack(path: $path) { HomeView() }.tag(0)
+            NavigationStack(path: $path) { SearchView() }.tag(1)  // ❌ Same path!
+        }
+    }
+}
+```
+
+✅ **Good: Per-tab RouterPath with deep link routing**
+```swift
+@Observable
+final class RouterPath {
+    var path: [AppRoute] = []
+
+    func navigate(to route: AppRoute) { path.append(route) }
+    func pop() { if !path.isEmpty { path.removeLast() } }
+    func popToRoot() { path.removeAll() }
+
+    func handle(url: URL) -> Bool {
+        guard let route = AppRoute(url: url) else { return false }
+        navigate(to: route)
+        return true
+    }
+}
+
+enum AppTab: Int, CaseIterable, Identifiable {
+    case home, search, notifications, profile
+    var id: Int { rawValue }
+}
+
+@Observable
+final class AppTabRouter {
+    var selectedTab: AppTab = .home
+
+    var homeRouter = RouterPath()
+    var searchRouter = RouterPath()
+    var notificationsRouter = RouterPath()
+    var profileRouter = RouterPath()
+
+    // Binding helper for each tab's path
+    func pathBinding(for tab: AppTab) -> Binding<[AppRoute]> {
+        Binding(
+            get: { self.router(for: tab).path },
+            set: { self.router(for: tab).path = $0 }
+        )
+    }
+
+    func router(for tab: AppTab) -> RouterPath {
+        switch tab {
+        case .home: return homeRouter
+        case .search: return searchRouter
+        case .notifications: return notificationsRouter
+        case .profile: return profileRouter
+        }
+    }
+
+    // Route deep link to correct tab
+    func handle(url: URL) {
+        guard let route = AppRoute(url: url) else { return }
+        let targetTab = route.preferredTab
+        selectedTab = targetTab
+        router(for: targetTab).navigate(to: route)
+    }
+}
+
+struct MainTabView: View {
+    @State private var tabRouter = AppTabRouter()
+
+    var body: some View {
+        TabView(selection: $tabRouter.selectedTab) {
+            Tab("Home", systemImage: "house", value: AppTab.home) {
+                NavigationStack(path: tabRouter.pathBinding(for: .home)) {
+                    HomeView(router: tabRouter.homeRouter)
+                        .navigationDestination(for: AppRoute.self) { route in
+                            routeDestination(route, router: tabRouter.homeRouter)
+                        }
+                }
+            }
+
+            Tab("Search", systemImage: "magnifyingglass", value: AppTab.search) {
+                NavigationStack(path: tabRouter.pathBinding(for: .search)) {
+                    SearchView(router: tabRouter.searchRouter)
+                        .navigationDestination(for: AppRoute.self) { route in
+                            routeDestination(route, router: tabRouter.searchRouter)
+                        }
+                }
+            }
+
+            // ... other tabs
+        }
+        .onOpenURL { url in
+            tabRouter.handle(url: url)  // ✅ Deep link dispatched to correct tab router
+        }
+    }
+}
+```
+
+---
+
 ## 6. Testing Strategies
 
 ### 6.1 Unit Testing