@leejungkiin/awkit 1.0.5 → 1.0.7

package/skills/smali-to-swift/phase-3-logic-build.md

@@ -0,0 +1,312 @@
+# 🔨 Phase 3: Logic Build (Per Feature) — iOS
+
+> **Zoom Level:** 3 — Code Implementation
+> **Goal:** Code logic behind the APPROVED UI shell for ONE feature.
+> **Input:** Approved Blueprint + Working SwiftUI Shell from Phase 2.
+> **Output:** Feature fully wired — UI + logic connected.
+
+---
+
+## ✅ PREREQUISITES
+
+Before writing ANY logic code, confirm:
+- [ ] Phase 0 App Map: approved
+- [ ] Phase 1 Architecture Blueprint: approved
+- [ ] Phase 2 Contracts: approved for THIS feature
+- [ ] Phase 2 UI Shell: approved, runs in Preview/Simulator
+
+> ⚠️ If UI is not approved yet, STOP. Go back to Phase 2.
+
+---
+
+## 📋 Implementation Order
+
+### 3.1: Domain Layer
+
+Implement from contracts defined in Phase 2:
+
+1. **Models** — structs (already drafted in 2.2, create actual files)
+2. **Repository protocols** — (already drafted in 2.3, create files)
+3. **UseCases** — implement execute() with repository calls
+
+```swift
+struct LoginUseCase {
+    private let authRepo: AuthRepository
+
+    func execute(email: String, password: String) async throws -> User {
+        try await authRepo.login(email: email, password: password)
+    }
+}
+```
+
+### 3.2: Data Layer
+
+1. **DTOs** — Codable structs matching API JSON
+2. **API Client** — async URLSession with proper error handling
+3. **SwiftData @Model** classes (if applicable)
+4. **Keychain / UserDefaults** wrappers (if applicable)
+5. **Repository implementation** — offline-first pattern
+
+```swift
+final class AuthRepositoryImpl: AuthRepository {
+    private let apiClient: APIClient
+    private let tokenStore: TokenStore
+
+    func login(email: String, password: String) async throws -> User {
+        let dto = try await apiClient.request(
+            AuthEndpoint.login(email: email, password: password),
+            responseType: LoginResponseDTO.self
+        )
+        await tokenStore.save(dto.accessToken)
+        return dto.user.toDomain()
+    }
+
+    func isLoggedIn() -> Bool {
+        tokenStore.hasToken
+    }
+}
+```
+
+### 3.3: DI Container
+
+```swift
+@MainActor
+final class AppContainer {
+    // Singletons
+    lazy var apiClient = APIClient(baseURL: Config.apiBaseURL)
+    lazy var tokenStore = TokenStore()
+
+    // Repositories
+    lazy var authRepository: AuthRepository = AuthRepositoryImpl(
+        apiClient: apiClient,
+        tokenStore: tokenStore
+    )
+
+    // UseCases
+    func makeLoginUseCase() -> LoginUseCase {
+        LoginUseCase(authRepo: authRepository)
+    }
+
+    // ViewModels
+    func makeLoginViewModel() -> LoginViewModel {
+        LoginViewModel(loginUseCase: makeLoginUseCase())
+    }
+}
+```
+
+### 3.4: ViewModel
+
+Implement using ViewState + Events + Actions from Phase 2.6:
+
+```swift
+@Observable
+final class LoginViewModel {
+    var state = LoginViewState()
+
+    private let loginUseCase: LoginUseCase
+    private var onEvent: ((LoginEvent) -> Void)?
+
+    init(loginUseCase: LoginUseCase) {
+        self.loginUseCase = loginUseCase
+    }
+
+    func setEventHandler(_ handler: @escaping (LoginEvent) -> Void) {
+        self.onEvent = handler
+    }
+
+    func handle(_ action: LoginAction) {
+        switch action {
+        case .updateEmail(let email):
+            state.email = email
+        case .updatePassword(let password):
+            state.password = password
+        case .togglePasswordVisibility:
+            state.isPasswordVisible.toggle()
+        case .submit:
+            login()
+        }
+    }
+
+    private func login() {
+        state.isLoading = true
+        state.error = nil
+        Task {
+            do {
+                let _ = try await loginUseCase.execute(
+                    email: state.email,
+                    password: state.password
+                )
+                state.isLoading = false
+                onEvent?(.navigateToHome)
+            } catch {
+                state.isLoading = false
+                state.error = error.localizedDescription
+            }
+        }
+    }
+}
+```
+
+### 3.5: Wire UI ↔ Logic ⭐ (NOT "code new UI")
+
+> **This step does NOT create new UI.** The UI already exists from Phase 2.8.
+> Only CONNECT the existing UI shell to the real ViewModel.
+
+**Changes needed on the UI shell:**
+
+```swift
+// Phase 2 code stays as the STATELESS "Content" view (for Preview):
+struct LoginScreenContent: View {
+    var state: LoginViewState = .normal
+    var onAction: (LoginAction) -> Void = { _ in }
+
+    var body: some View {
+        // ... all UI code from Phase 2.8 — DO NOT MODIFY
+    }
+}
+
+// Previews still work:
+#Preview("Normal") { LoginScreenContent(state: .normal) }
+#Preview("Loading") { LoginScreenContent(state: .loading) }
+
+// ADD a NEW wrapper that wires ViewModel:
+struct LoginScreen: View {
+    @State private var viewModel: LoginViewModel
+    var onNavigateToHome: () -> Void
+
+    init(container: AppContainer, onNavigateToHome: @escaping () -> Void) {
+        _viewModel = State(initialValue: container.makeLoginViewModel())
+        self.onNavigateToHome = onNavigateToHome
+    }
+
+    var body: some View {
+        LoginScreenContent(
+            state: viewModel.state,
+            onAction: viewModel.handle
+        )
+        .onAppear {
+            viewModel.setEventHandler { event in
+                switch event {
+                case .navigateToHome:
+                    onNavigateToHome()
+                case .showError(let msg):
+                    // handle
+                    break
+                }
+            }
+        }
+    }
+}
+```
+
+**Wire Checklist:**
+- [ ] Wrapper view injects ViewModel from DI container
+- [ ] State bindings: ViewModel.state → Content view
+- [ ] Action bindings: Content onAction → ViewModel.handle()
+- [ ] Event handling: navigation, alerts
+- [ ] Previews still work (they use the stateless Content view)
+
+### 3.6: Integration Test ⭐
+
+Verify UI + logic end-to-end:
+
+```markdown
+### 🧪 Integration: [Feature]
+
+Functional:
+- [ ] API calls succeed, data displays on UI
+- [ ] Loading state shows/hides at right time
+- [ ] Error state displays correct message
+- [ ] Navigation works as expected
+- [ ] Form validation works
+
+Data:
+- [ ] Request format matches original app
+- [ ] Response parses correctly
+- [ ] Token/session stored properly
+- [ ] Crypto output matches original (if applicable)
+
+Edge Cases:
+- [ ] Empty input handling
+- [ ] Network error handling
+- [ ] Back navigation
+- [ ] App backgrounding/foregrounding
+```
+
+---
+
+## 🔒 CRYPTO UTILS (Special Handling)
+
+If the feature involves encryption/hashing:
+
+1. Read disassembly carefully — exact algorithm, padding, encoding
+2. Implement in Swift — preserve exact input/output
+3. Unit test IMMEDIATELY with known pairs
+
+```swift
+import CryptoKit
+import CommonCrypto
+
+enum CryptoUtils {
+    static func md5Hash(_ input: String) -> String {
+        let data = Data(input.utf8)
+        var digest = [UInt8](repeating: 0, count: Int(CC_MD5_DIGEST_LENGTH))
+        data.withUnsafeBytes { CC_MD5($0.baseAddress, CC_LONG(data.count), &digest) }
+        return digest.map { String(format: "%02x", $0) }.joined()
+    }
+}
+
+// MANDATORY test
+final class CryptoUtilsTests: XCTestCase {
+    func testMD5MatchesOriginal() {
+        XCTAssertEqual("expected_hash", CryptoUtils.md5Hash("known_input"))
+    }
+}
+```
+
+> ⚠️ Crypto functions MUST produce identical output. Any mismatch breaks server communication.
+
+---
+
+## ✅ Checkpoint
+
+```markdown
+## ✅ Feature Complete: [Feature Name]
+
+### Files created:
+- Domain/Models/User.swift
+- Domain/Repositories/AuthRepository.swift
+- Domain/UseCases/LoginUseCase.swift
+- Data/Network/Endpoints/AuthEndpoint.swift
+- Data/Network/DTOs/LoginRequestDTO.swift, LoginResponseDTO.swift
+- Data/Repositories/AuthRepositoryImpl.swift
+- DI/AppContainer.swift (updated)
+- Presentation/Screens/Auth/LoginViewModel.swift
+- Presentation/Screens/Auth/LoginScreen.swift ← wired (from Phase 2)
+
+### Tests:
+- [ ] Crypto utils verified (if applicable)
+- [ ] API contract matches original
+- [ ] UI + Logic e2e works
+
+### ⏭️ Next Feature: [Name]
+→ Return to Phase 2 (Blueprint + UI Design)
+```
+
+---
+
+## 🔄 Feature Loop
+
+```
+Phase 2 (Blueprint + UI for Feature X) → GATE → Phase 3 (Logic for X) → Checkpoint
+    ↓
+Phase 2 (Blueprint + UI for Feature Y) → GATE → Phase 3 (Logic for Y) → Checkpoint
+    ↓
+... (repeat for all features from Architecture Build Order)
+    ↓
+Phase 4: Final Parity Check & Quality Gate
+```
+
+---
+
+*Phase 3: Logic Build — Wire logic behind approved UI*

package/workflows/mobile/reverse-android-build.md

@@ -1,170 +1,210 @@
 ---
-description: 🔨 RE Android Phase 2+3 — Per-feature Blueprint → Implementation → Parity Check
+description: 🔨 RE Android Phase 2+3+4 — Blueprint + UI Shell → Logic Build → Final Parity (UI-First)
 parent: reverse-android
 ---
 
-# /re-android-build — Blueprint & Build (Per Feature)
+# /re-android-build — Blueprint + UI + Build (Per Feature)
 
-> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 2+3
+> **Parent:** [`/reverse-android`](reverse-android.md) → Phase 2+3+4
 > **Prerequisite:** Completed Architecture from [`/re-android-design`](reverse-android-design.md)
-> **Skill:** `smali-to-kotlin` → `phase-2-blueprint.md` + `phase-3-build.md`
+> **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
 
 ---
 
-## 🔄 Feature Loop
+## 🔄 Feature Loop (UI-First)
 
 ```
 For each feature (from Architecture Build Order):
-    Phase 2: Blueprint (Zoom 2 — signatures only)
-        ↓ [User approves]
-    Phase 3: Implementation (Zoom 3 — full code)
-        ↓ [Checkpoint]
+    Phase 2: Blueprint + UI (contracts + visual shell)
+        ↓ 🚦 GATE: User approves UI + contracts
+    Phase 3: Logic Build (domain → data → wire)
+        ↓ 📊 CHECKPOINT
     → Next feature
 ```
 
 ---
 
-## 📐 Phase 2: Feature Blueprint (Zoom 2)
+## 📐🎨 Phase 2: Blueprint + UI Design
 
-> **Output:** Contracts, interfaces, state design. **Signatures only, no bodies.**
+> **Output:** Approved contracts + Working Compose UI shell with mock data.
 
-### 2.1: Deep Smali Reading
+### Part A: Contracts (signatures only)
 
-Read Smali files for the chosen feature. Extract:
-- Class hierarchy, fields, method signatures
-- String constants (URLs, keys, messages)
-- Control flow → business rules (document, don't code)
-
-### 2.2: Contracts
-
-Define for this feature:
+#### 2.1: Deep Smali Reading
+Read Smali files for the chosen feature. Extract class hierarchy, fields, method signatures,
+string constants, control flow. See `smali-reading-guide.md`.
 
+#### 2.2–2.5: Define Contracts
 ```kotlin
-// Domain Model
-data class [Model](val field1: Type, ...)
+// 2.2 Domain Model
+data class [Model](val field: Type, ...)
 
-// Repository Interface
+// 2.3 Repository Interface
 interface [Feature]Repository {
     suspend fun [method](...): Result<[Type]>
-    fun [stream](): Flow<[Type]>
 }
 
-// API Interface
+// 2.4 API Interface
 interface [Feature]Api {
     @[METHOD]("[endpoint]")
     suspend fun [method](...): [Response]
 }
 
-// UseCase
+// 2.5 UseCase
 class [Action]UseCase(repo: [Feature]Repository) {
     suspend operator fun invoke(...): Result<[Type]> // TODO()
 }
 ```
 
-### 2.3: UI State Design
-
+#### 2.6: UI State Design
 ```kotlin
 data class [Screen]UiState(
     val field: Type = default,
     val isLoading: Boolean = false,
     val error: String? = null
 )
-
 sealed interface [Screen]Event { /* navigation, snackbar */ }
 sealed interface [Screen]Action { /* user interactions */ }
 ```
 
-### 2.4: Wireframe + File List
+### Part B: UI Visual Shell
+
+#### 2.7: Resource Extraction ⭐ (BEFORE UI code!)
+
+```bash
+# Only resources for THIS screen
+grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+grep -o '@color/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+```
 
-ASCII wireframe + list of files to create.
+Copy ONLY needed resources. Verify they compile.
 
-### ✅ Blueprint Gate
+#### 2.8: UI Implementation ⭐ (Visual shell with mock data)
 
+- Use UiState from 2.6 with hardcoded defaults
+- Use REAL resources from 2.7
+- Create `[Screen]Content` composable (stateless)
+- Match visual parity with original app
+- NO ViewModel connection, NO real API calls
+
+```kotlin
+@Composable
+fun [Screen]Content(
+    uiState: [Screen]UiState = [Screen]UiState(),  // Mock
+    onAction: ([Screen]Action) -> Unit = {}          // No-op
+) {
+    // Full Compose UI matching original app
+}
+
+@Preview @Composable
+private fun NormalPreview() { AppTheme { [Screen]Content() } }
+
+@Preview @Composable
+private fun LoadingPreview() { AppTheme { [Screen]Content([Screen]UiState(isLoading = true)) } }
+
+@Preview @Composable
+private fun ErrorPreview() { AppTheme { [Screen]Content([Screen]UiState(error = "Error")) } }
 ```
-"📐 Blueprint cho [Feature] xong. Anh xem OK không? → Em bắt đầu code."
+
+#### 2.9: Visual Parity Check ⭐
+
+Compare with original app:
+- [ ] Layout structure matches
+- [ ] Colors, typography, spacing correct
+- [ ] Icons/images positioned correctly
+- [ ] All states: normal, loading, error, empty
+
+### 🚦 UI + Contracts Gate (MANDATORY)
+
+```
+"📐🎨 Blueprint + UI cho [Feature] xong:
+📝 Contracts: [N] models, [N] repos, [N] use cases, [N] APIs
+🎨 UI: [Screen] with [N] state previews
+📸 Visual Parity: [OK / needs adjustment]
+
+→ ✅ Approve → Phase 3 (Logic Build)
+→ 🎨 Adjust UI → fix then re-check
+→ 📝 Adjust contracts → revise"
 ```
 
+> ⚠️ **DO NOT proceed to Phase 3 without user approval.**
+
 ---
 
-## 🔨 Phase 3: Implementation (Zoom 3)
+## 🔨 Phase 3: Logic Build
 
-> **Output:** Full production-quality Kotlin code for THIS feature only.
+> **Output:** Full production-quality Kotlin code. Wire logic to EXISTING UI.
 
 ### 3.1: Domain Layer
-
-- Models (data classes from Blueprint)
-- Repository interfaces (from Blueprint)
-- UseCases (implement invoke with repo calls)
+Models + Repository interfaces + UseCases (implement invoke with repo calls)
 
 ### 3.2: Data Layer
-
-- DTOs (@Serializable)
-- Retrofit API interface
-- Room entities + DAOs (if applicable)
-- Repository implementation (offline-first)
+DTOs + Retrofit API + Room (if applicable) + Repository implementation
 
 ### 3.3: DI Module
-
-- Hilt @Module with @Binds for repository
+Hilt @Module with @Binds for repository
 
 ### 3.4: ViewModel
+@HiltViewModel with StateFlow + SharedFlow, implements onAction()
 
-- @HiltViewModel with StateFlow + SharedFlow
-- Implement onAction() handler from Blueprint actions
-
-### 3.5: Compose Screen
+### 3.5: Wire UI ↔ Logic ⭐ (NOT "code new UI")
 
-- Collect state with collectAsStateWithLifecycle()
-- UI from wireframe
-- LaunchedEffect for events
+The UI already exists from Phase 2.8. Only CONNECT it:
 
-### 3.6: Resource Extraction (On-Demand only)
-
-```bash
-# Only resources for THIS screen
-grep -o '@drawable/[a-z_]*' [apktool_dir]/res/layout/activity_[screen].xml | sort -u
+```kotlin
+// Keep stateless Content composable from Phase 2 (for Preview):
+// [Screen]Content(uiState, onAction) — DO NOT MODIFY
+
+// ADD wrapper that wires ViewModel:
+@Composable
+fun [Screen](
+    viewModel: [Screen]ViewModel = hiltViewModel(),
+    onNavigate: () -> Unit
+) {
+    val uiState by viewModel.uiState.collectAsStateWithLifecycle()
+    LaunchedEffect(Unit) {
+        viewModel.events.collect { event -> /* handle navigation */ }
+    }
+    [Screen]Content(uiState = uiState, onAction = viewModel::onAction)
+}
 ```
 
-### 🔒 Crypto Utils (Special)
+### 3.6: Integration Test ⭐
+- [ ] API calls succeed, data displays
+- [ ] Loading/error states work
+- [ ] Navigation correct
+- [ ] Crypto output matches (if applicable)
 
-If feature involves crypto/hashing:
-1. Read Smali carefully (exact algorithm)
-2. Implement in Kotlin
-3. Unit test IMMEDIATELY with known pairs
-
-> ⚠️ Crypto MUST produce identical output to original app.
+### 🔒 Crypto Utils (Special)
+If crypto involved: implement + unit test IMMEDIATELY with known pairs.
+> ⚠️ MUST produce identical output.
 
 ### ✅ Feature Checkpoint
 
 ```markdown
 ## ✅ Feature Complete: [Name]
-
-### Files created: [list]
-### Resources extracted: [only needed]
-### Tests: [crypto verified? API matches?]
-
-### ⏭️ Next Feature: [Name]
-→ Return to Phase 2 (Blueprint) for next feature
+Files: [list] | Resources: [count] | Tests: [status]
+⏭️ Next Feature: [Name] → Return to Phase 2
 ```
 
 ---
 
-## ✅ Final Parity Check (After ALL features)
+## ✅ Phase 4: Final Parity Check (After ALL features)
 
 ### Checklist
 - [ ] API Parity — all endpoints match (headers, body, encoding)
 - [ ] Data Parity — crypto/hash output identical
 - [ ] UI Parity — screen-by-screen comparison
 - [ ] Edge Cases — empty states, errors, offline, lifecycle
-- [ ] Build & Test: `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
+- [ ] Build: `./gradlew assembleDebug && ./gradlew test && ./gradlew lint`
 
 ### 🎉 Final Summary
 
 ```markdown
 ## ✅ Reverse Engineering Complete!
-- Screens: [count] | Features: [count]
-- Libs reused: [count] | Replaced: [count]
-- Tests: [pass/fail] | Lint: [pass/warnings]
+- Screens: [N] | Features: [N]
+- Libs reused: [N] | Replaced: [N]
+- Tests: [pass/fail] | Lint: [warnings]
 
 ⏭️ Next: /test → /deploy → /code-janitor
 ```
@@ -175,8 +215,8 @@ If feature involves crypto/hashing:
 
 - **Parent:** [`/reverse-android`](reverse-android.md)
 - **Previous:** [`/re-android-design`](reverse-android-design.md) (Phase 1)
-- **Skill:** `smali-to-kotlin` → `phase-2-blueprint.md` + `phase-3-build.md`
+- **Skill:** `smali-to-kotlin` → `phase-2-blueprint-ui.md` + `phase-3-logic-build.md`
 
 ---
 
-*re-android-build v3.0.0 — Phase 2+3: Blueprint & Build*
+*re-android-build v4.0.0 — UI-First Blueprint + Build*

package/workflows/mobile/reverse-android-design.md

@@ -84,16 +84,19 @@ app/src/main/java/[package]/
 └── util/
 ```
 
-## 🔢 Step 6: Build Order
+## 🔢 Step 6: Build Order (UI-First) ⭐
 
 | # | Phase | Scope | Complexity |
 |---|-------|-------|-----------|
-| 1 | 🟢 Setup | Project + DI + Theme | Low |
-| 2 | 🟢 Models | Domain data classes | Low |
-| 3 | 🟡 Data | API + Room + DataStore | Medium |
-| 4 | 🟡 Utils | Crypto, formatters | Medium |
-| 5 | 🔴 Features | Per-feature Blueprint→Build | High |
-| N | 🔴 Final | Parity check | High |
+| 1 | 🟢 Foundation | Project + DI skeleton + Theme/Design System | Low |
+| 2 | 🟢 Navigation | Routes, tab bar, NavGraph | Low |
+| 3 | 🔵 Per Feature | Blueprint (contracts) + UI Shell (visual) | Medium |
+| 4 | 🚦 UI Gate | User approves UI before logic | — |
+| 5 | 🟡 Per Feature | Logic Build (Domain → Data → VM → Wire UI) | High |
+| 6 | 📦 SDKs | Third-party SDK + Native libs integration | Medium |
+| N | 🔴 Final | Full Parity Check | High |
+
+> **UI-First:** Design and approve UI before coding logic for each feature.
 
 ## 🔧 Step 7: Tech Stack Confirmation